Desenvolvimento Código Aberto

Existem muitos estilos de programação e estes chamados de paradigmas. As linguagens mais antigas possuem o estilo processual (procedural) , pois da ênfase sobre a especificação computacional de procedimentos, enquanto as linguagens mais modernas são orientadas a objeto, as linguagens que evoluirão ou as que nasceram de uma linguagem de outro paradigma e ainda mantém as suas características seja por opção ou por compatibilidade, estas são chamadas de hibridas, que em ciência da computação é uma linguagem de programação que se baseia em elementos de mais de um paradigma de programação.

Um paradigma de programação fornece e determina a visão que o programador possui sobre a estruturação e execução do programa. Por exemplo, em programação orientada a objetos, programadores podem abstrair um programa como uma coleção de objetos que interagem entre si, enquanto em programação funcional os programadores abstraem o programa como uma sequência de funções executadas de modo empilhado.

Em linguagens multi paradigmas a maioria da programação hoje em dia é orientada a objeto, o que significa que o foco está em objetos e suas interações.

Em programação orientada a objetos existem dois tipos de métodos, chamados métodos de classe e métodos de objetos. Métodos de classe são identificados pela palavra-chave static na primeira linha. Qualquer método que não possua a palavra-chave static é um método de objeto. Este significado pode variar dependendo da linguagem de programação vide Python.

Então podemos dividir os métodos entre estáticos e não estáticos:

Estáticos: métodos estáticos não requerem uma instância da classe nem podem acessar implicitamente os dados (this, self, Me, etc.) de tal instância. Um método estático é distinguido em algumas linguagens de programação com a palavra-chave static colocada em algum lugar na assinatura do método.

Não Estáticos: métodos não estáticos requerem uma instância da classe e podem acessar implicitamente os dados (this, self, Me, etc.) de tal instância. Este método exige um tipo de código diferente da programação de códigos estáticos, pois está sempre se referindo a instancia do objeto e não da classe.

Código do Método Objeto:

• Não declarar a instrução estática.
• Nomear o  método para ser mais idiomático.
• Remover o parâmetro da própria classe na declaração.
• Dentro do método de objeto você deve se referir as variáveis ​​de instância como variáveis ​​locais.

Exemplo:

A por default a maioria das linguagens de  programação orientada a objetos fornecem um método chamado equals(igual) que define a equivalência entre objetos As classes default fornecem o método  equals que já faz toda a coisa do modo correto. Mas para os tipos definidos pelo usuário o comportamento padrão é o mesmo que identidade, que normalmente não é o resultado que você quer. Então tudo o que temos a fazer é reescrever o método  equals para nosso objeto.

O modo correto é criar uma função Override para o método equals, mas aqui vamos escrever a função com o nome traduzido para que fique claro a diferença entre métodos de classe e métodos de objeto, que é o objetivo deste post.

Java

Classe #1

public class Program
 {

public static void main(String[] args)
 {
   // Instancia dos Objetos

   Quadrado q1 = new Quadrado(32);
   Quadrado q2 = new Quadrado(32);

   System.out.println("Verifica se os Objetos são iguais\n");

   // Usa método da Classe
   System.out.print("Testa método da classe:");
   System.out.println(Quadrado.iguaisQ(q1, q2));

   // Usa método do Objeto
   System.out.print("Testa método do objeto:");
   System.out.println(q1.iguais(q2));
  }
}

Classe #2

public class Quadrado
 {
    private double lado;
Quadrado (double lado)
     {
      this.lado = lado;
     }
     // Método da Classe - Estatico
     static public boolean iguaisQ(Quadrado q1, Quadrado q2)
     {
      return (q1.lado == q2.lado);
     }
     // Método do Objeto  - Não Estatico
     public boolean iguais(Quadrado q2)
     {
      return (lado == q2.lado);
     }
}

C++

Classe #1

#include "stdafx.h"
#include <iostream>
#include "Quadrado.h"
using namespace std;

int _tmain(int argc, _TCHAR* argv[])
 {

  // Instancia dos Objetos
  Quadrado q1 (32);
  Quadrado q2 (32);

  cout << "Verifica se os Objetos são iguais\n" << endl;

  // Usa método da Classe
  cout << "Testa método da classe:";
  cout << Quadrado::iguaisQ(q1, q2) << endl;

  // Usa método do Objeto
  cout << "Testa método do objeto:";
  cout << q1.iguais(q2) << endl;
  system("pause");
  return 0;
 }

Classe #2

#include "stdafx.h"
#include <iostream>
using namespace std;

class Quadrado
 {
 private:

 double lado;

 public:

 Quadrado(double lado)
  {
   this->lado = lado;
  }

  // Método da Classe - Estatico
  static  bool iguaisQ(Quadrado q1, Quadrado q2)
  {
   return (q1.lado == q2.lado);
  }

  // Método do Objeto  - Não Estatico
  bool iguais(Quadrado q2)
  {
   return (lado == q2.lado);
  }
};

C#

Classe #1

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     class Program
     {
         static void Main(string[] args)
         {

           // Instancia dos Objetos
           Quadrado q1 = new Quadrado(32);
           Quadrado q2 = new Quadrado(32);
           Console.WriteLine("Verifica se os Objetos são iguais\n");

          // Usa método da Classe
          Console.Write("Testa método da classe:");
          Console.WriteLine(Quadrado.iguaisQ(q1, q2));

          // Usa método do Objeto
          Console.Write("Testa método do objeto:");
          Console.WriteLine(q1.iguais(q2));
          Console.ReadKey();
         }
     }
 }

Classe #2

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     class Quadrado
     {
       private double lado;

             public Quadrado(double lado)
             {
                 this.lado = lado;
             }

             // Método da Classe - Estatico
             static public Boolean iguaisQ(Quadrado q1, Quadrado q2)
             {
                 return (q1.lado == q2.lado);
             }

             // Método do Objeto  - Não Estatico
             public Boolean iguais(Quadrado q2)
             {
                 return (lado == q2.lado);
             }
    }
 }

Python

Classe #1

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# objetos_metodos.py
class Q:
     lado = 0
class Quadrado(Q) :
     def __init__(self, lado = 0):
         self.lado = lado

     def iguais(self,q2 = Q()):
         return self.lado == q2.lado

     @staticmethod
     def iguaisQ(q1 = Q() , q2 = Q()):
         return q1.lado == q2.lado

# Instancia dos Objetos
q1 = Quadrado(32)
q2 = Quadrado(32)

print "Verifica se os Objetos são iguais\n"

# Usa método da Classe
print "Testa método da classe:"
print Quadrado.iguaisQ(q1, q2)

# Usa método do Objeto
print "Testa método do objeto:"
print q1.iguais(q2)

raw_input()

Abap

Classe #1

*&---------------------------------------------------------------------*
*& Report  ZMETODOS
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Metodos Estaticos e de Objetos
*&---------------------------------------------------------------------*

REPORT  ZMETODOS.

class Quadrado DEFINITION.

PUBLIC SECTION.

DATA lado TYPE i.

METHODS:

  CONSTRUCTOR IMPORTING lado TYPE i,

  IGUAIS IMPORTING Q2 TYPE REF TO QUADRADO
         RETURNING VALUE(resultado) TYPE ABAP_BOOL.

CLASS-METHODS

  IGUAISQ IMPORTING  Q1 TYPE REF TO QUADRADO
                     Q2 TYPE REF TO QUADRADO
          RETURNING VALUE(resultado) TYPE ABAP_BOOL.

ENDCLASS.

CLASS QUADRADO IMPLEMENTATION.

  METHOD CONSTRUCTOR.
    CALL METHOD SUPER->CONSTRUCTOR.
    me->LADO = LADO.
  ENDMETHOD.

  METHOD IGUAIS.
    IF me->LADO EQ  Q2->LADO.
      RESULTADO = ABAP_TRUE.
    ELSE.
      RESULTADO = ABAP_FALSE.
    ENDIF.
  ENDMETHOD.

  METHOD IGUAISQ.
    IF Q1->LADO EQ  q2->LADO.
      RESULTADO = ABAP_TRUE.
    ELSE.
      RESULTADO = ABAP_FALSE.
    ENDIF.
  ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

DATA Q1 TYPE REF TO QUADRADO.
DATA Q2 TYPE REF TO QUADRADO.
DATA RT TYPE ABAP_BOOL.

CREATE OBJECT Q1 EXPORTING LADO = 32.
CREATE OBJECT Q2 EXPORTING LADO = 32.

WRITE : / 'Verifica se os Objetos são iguais'.

* Usa método da Classe

WRITE: / 'Testa método da classe:'.

QUADRADO=>IGUAISQ( exporting Q1 = Q1 Q2 = Q2 receiving RESULTADO = RT ).
PERFORM RESULTADO USING RT.

* Usa método do Objeto

WRITE : / 'Testa método do objeto:'.

RT = Q1->IGUAIS( Q2 ).
PERFORM RESULTADO USING RT.

FORM RESULTADO USING VALUE(R) TYPE ABAP_BOOL.
  IF R = ABAP_TRUE.
    WRITE :  'TRUE'.
  ELSE.
    WRITE :  'FALSE'.
  ENDIF.
ENDFORM.

Método de sobrecarga é uma característica encontrada em várias linguagens de programação, que permite a criação de vários métodos com o mesmo nome, que diferem uns dos outros no tipo da entrada e a saída da função. É simplesmente definido como a capacidade de uma função para executar diferentes tarefas.

Construtores, são usados ​​para criar instâncias de um objeto, também podem ser sobrecarregados em algumas linguagens de programação orientadas a objeto. Porque em muitas línguas o nome do construtor é pré-determinado pelo nome da classe. Sempre que são necessários vários construtores são implementados como funções sobrecarregadas. Um construtor padrão não tem parâmetros, instanciam os membros do objeto com um valor zero.

Ter pelo menos dois construtores é quase obrigatório em programação orientada a objeto, o construtor default facilita criar métodos Modifiers e Fill-in, pois é possível manipular objetos sem ter que passar nenhum parâmetros para eles e trabalhar com seus atributos dentro dos métodos, enquanto ao mesmo tempo é pratico criar objetos com valores inicializados, sem ter que escrever varias linhas.

Em Java, C++ e C# sobrecarregar um construtor  é simples, basta apenas criar quantos construtores forem necessários, por outro lado linguagens hibridas como Abap e Python (C++ também é uma linguagem hibrida, mas é muito poderosa) não é possível  sobrecarregar o método construtor, mas como este é um recurso extremamente útil, existe um modo de criar o mesmo efeito de sobrecarga nos construtores.

Abap possui a palavra chave OPTIONAL, na qual marca o parâmetro como opcional, deste modo é possível criar um objeto que simula o construtor Overload.

Python é uma linguagem moderna e bem flexível em sua sintaxe e possibilita inicializar o construtor atribuindo valores a variável e podemos usar a palavra chave None para dizer que o conteúdo é vazio, simulando deste modo um construtor Overload.

Exemplo:

Neste exemplo criamos dois construtores : o construtor default e um construtor Overload, para as linguagens Java, C++ e C# e para as  linguagens Abap e Python usamos um recurso da língua para simular o construtor Overload obtendo o mesmo efeito.

Java

public class Sobrecarga
  {
     int x = 0;
     int y = 0;

     public Sobrecarga () {}

     public Sobrecarga(int x, int y)
   {
     this.x = x;
     this.y = y;
   }

   public  void imprimeSb()
   {
     System.out.println("X=" + this.x + " Y=" + this.y);
   }

   public static void main(String[] args)
   {
       Sobrecarga sc1 = new Sobrecarga();
       Sobrecarga sc2 = new Sobrecarga(10,20);
       System.out.println("Construtor Default");
       sc1.imprimeSb();
       System.out.println("Construtor Overload");
       sc2.imprimeSb();
  }
 }

C++

#include "stdafx.h"
#include <iostream>

using namespace std;

class Sobrecarga
  {
  public:
   int x = 0;
   int y = 0;

   Sobrecarga( )   {   }

   Sobrecarga(int x, int y)
   {
    this->x = x;
    this->y = y;
   }

  void imprimeSb()
   {
    cout << "X=" << this->x << " Y=" << this->y << endl;
   }
};

int _tmain(int argc, _TCHAR* argv[])
  {
   Sobrecarga sc1;  Sobrecarga sc2(10, 20);
   cout << "Construtor Default" << endl;
   sc1.imprimeSb();

   cout << "Construtor Overload" << endl;
   sc2.imprimeSb();
   system("pause");
   return 0;
  }

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace DesenvolvimentoAberto
  {
      class Sobrecarga
      {
          int x = 0;
          int y = 0;

         public Sobrecarga() { }

         public Sobrecarga(int x, int y)
          {
              this.x = x;
              this.y = y;
          }

      public void imprimeSb()
       {
         Console.WriteLine("X=" + this.x + " Y=" + this.y);
       }

          static void Main(string[] args)
          {
              Sobrecarga sc1 = new Sobrecarga();
              Sobrecarga sc2 = new Sobrecarga(10,20);
              Console.WriteLine("Construtor Default");
              sc1.imprimeSb();
              Console.WriteLine("Construtor Overload");
              sc2.imprimeSb();
              Console.ReadKey();
          }
      }
  }

Abap

*&---------------------------------------------------------------------*
*& Report  ZOBJETOS_OVER
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Construtor Overload
*&---------------------------------------------------------------------*

REPORT  ZOBJETOS_OVER.

* Declara Classe

Class SobreCarga DEFINITION.

PUBLIC SECTION.
   DATA X TYPE i.
    DATA Y TYPE i.

" Efeito Overload
METHODS:
CONSTRUCTOR IMPORTING
             X TYPE i OPTIONAL
             Y TYPE i OPTIONAL,
ImprimeSB.

ENDCLASS.

Class SOBRECARGA IMPLEMENTATION.

 METHOD CONSTRUCTOR.
     me->X = X.
     me->Y = Y.
 ENDMETHOD.

 METHOD ImprimeSB.
     WRITE: / 'X=', me->X, 'Y=', me->Y.
 ENDMETHOD.

ENDCLASS.

START-OF-SELECTION.

DATA SB1 TYPE REF TO SOBRECARGA.
DATA SB2 TYPE REF TO SOBRECARGA.

* Cria Objetos Construtor Default e Overload
CREATE OBJECT SB1.
CREATE OBJECT SB2 EXPORTING X = 10 Y = 20.

WRITE: / 'Construtor Default:'.
SB1->IMPRIMESB( ).
WRITE: / 'Construtor Overload:'.
SB2->IMPRIMESB( ).

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# sobrecarga.py

class SobreCarga:
      x = 0
      y = 0
      def __init__(Self,x= None, y = None):
          if (x is not None) and (y is not None):
              Self.x = x
              Self.y = y
      def ImprimeSb(Self):
          print "X=", Self.x, "Y=", Self.y

sc1 = SobreCarga();
sc2 = SobreCarga(10,20);
print "Construtor Default"
sc1.ImprimeSb();
print "Construtor Overload"
sc2.ImprimeSb();
raw_input()

Já sabemos que é legal um método invocar o outro método, e vimos vários exemplos destes. Mas também é legal um método invocar ele mesmo. Pode não ser óbvio  o por que é isto é necessário, mas acaba por ser uma das coisas mais interessantes  que um programa pode fazer e este tipo de técnica é chamada de recursão.

Recursão é o processo de repetir itens de uma forma auto similar. Por exemplo, quando as superfícies dos dois espelhos são exatamente paralela uma com a outra as imagens que ocorrem aninhadas são uma forma de recursividade infinita. O termo tem uma variedade de significados específicos para uma variedade de disciplinas que vão desde a lógica linguística. A aplicação mais comum da recursividade é em matemática e ciência da computação, no que se refere a um método de definição de funções em que a função a ser definida é aplicada dentro de sua própria definição.

Mas é preciso planejar bem as recursões pois se houver erros em sua lógica, assim como os laços as recursões também podem ser infinitas.

Exemplo:

Neste exemplo vamos programar uma contagem regressiva  utilizando um método recursivo.

Java

public class Recursiva
 {
  static void contagemRegressiva (int n )
  {
    if ( n == 0 )
    {
      System.out.println("Explosão!!!");
    }
    else
    {
      System.out.println(n);
      contagemRegressiva (n-1);
    }
  }
  public static void main(String[] args)
  {
   int contagem = 10;
   System.out.println("Iniciando contage regressiva");
   contagemRegressiva(contagem);
  }
}

C++

#include "stdafx.h"
#include <iostream>
using namespace std;

static void contagemRegressiva(int n)
 {
  if (n == 0)
  {
    cout << "Explosão!!!" << endl;
  }
  else
  {
    cout << n << endl;   contagemRegressiva(n - 1);
  }
 }

int _tmain(int argc, _TCHAR* argv[])
 {
  int contagem = 10;
  cout << "Iniciando contagem regressiva." << endl;
  contagemRegressiva(contagem);
  system("pause");
  return 0;
 }

C#

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace DesenvolvimentoAberto
 {
     class Program
     {
         static void contagemRegressiva (int n )
      {
        if ( n == 0 )
        {
               Console.WriteLine("Explosão!!!");
        }
        else
        {
               Console.WriteLine(n);
               contagemRegressiva (n-1);
        }
      }

         static void Main(string[] args)
         {
             int contagem = 10;
             Console.WriteLine("Iniciando contagem regressiva");
             contagemRegressiva(contagem);
             Console.ReadKey();
         }
     }
 }

Python

#!/usr/bin/env python
# -*- coding: latin-1 -*-
# Desenvolvimento Aberto
# recursivo.py
# Importa OS
import os

# Limpa a tela
os.system("clear")

def ContagemRegressiva (n):
     if (n==0):
         print"Explosão!!!"
     else:
         print n
         ContagemRegressiva(n-1)

contagem = 10
print "Inciando contagem regressiva"
ContagemRegressiva (contagem)

raw_input()

Abap

*&---------------------------------------------------------------------*
*& Report  ZRECURSIVO
*&
*&---------------------------------------------------------------------*
*& Desenvolvimento Aberto
*& Metodos Recursivos
*&---------------------------------------------------------------------*

REPORT  ZRECURSIVO.
PARAMETERS :CONTAGEM TYPE i.

WRITE : / 'Iniciando contage regressiva.'.

PERFORM CONTAGEM_REGRESSIVA USING CONTAGEM.

FORM CONTAGEM_REGRESSIVA USING N TYPE i.
  IF ( N EQ 0 ).
    WRITE : / 'Explosão!!!'.
  ELSE.
    WRITE : / N.
    N = N - 1.
    PERFORM CONTAGEM_REGRESSIVA USING  N.
  ENDIF.
ENDFORM.

Em computação, um programador, desenvolvedor, coder ou engenheiro de software refere-se a alguém que faz programação de computadores e escreve software.

Um programador pode ser alguém que desenvolve ou faz manutenção de softwares em um grande sistema ou alguém que desenvolve software para uso em computadores pessoais.

Os desenvolvedores profissionais gastam menos de 10 por cento do seu tempo de trabalho escrevendo código, consomem cerca de 60 por cento do tempo de trabalho em um projeto,  na análise de problemas, concebendo soluções, documentando as decisões, depurando, mantendo ou melhorando o  código fonte.

Os 30 por cento restantes do tempo de um desenvolvedor é tomado por reuniões ou simplesmente desperdiçado (Às vezes, não há nenhuma diferença entre reuniões e tempo perdido.)

Se você estiver escrevendo um programa que é maior do que algumas linhas, então não é o bastante apenas sentar e começar a codificação. Você precisa dar três passos para tornar o seu programa o melhor possível.

Os 3 Ds –  Documentação, Design e Depuração

1. Documentação: Certificar-se de que outras pessoas podem ler o seu programa.
2. Design: Ter certeza que seu programa resolve o problema certo e está organizado para que seja eficiente e potencialmente reutilizável.
3. Depuração: Certificar-se de que seu programa não tenha nenhum erro e que ele responda adequadamente quanto a entrada de dados errados.

Documentação

Documentação torna possível ler, usar e manter um programa:

• Na programação, a documentação é toda a escrita associada ao seu programa que não seja um código.
• Em uma linguagem de programação, legibilidade é uma virtude nobre.
• Isso significa que seu código é parte da documentação também.
• Escolher bons nomes faz parte da documentação!
• LEMBRE-SE, programação, começa e termina com a documentação.
• Comece por escrever o problema que o seu programa se destina a resolver.
• Antes mesmo de começar a escrever o seu programa, é uma boa ideia escrever notas sobre o objetivo do programa.
• Finja que você precisa explicá-lo para outra pessoa, e se você tem alguém para ler a notas, melhor.
• Termine, certificando-se de que a documentação ainda corresponde ao programa.

Se você não escrever a documentação, você vai achar que é difícil usar ou manter o seu programa depois de passado seis meses (mesmo se você é a única pessoa que usa o programa).

Design

Projetar é realmente um atalho para duas partes interligadas de programação: análise e design.

O que você realmente quer?

Análise é o processo de determinar o problema que você está tentando resolver. É semelhante ao processo que um arquiteto faz você passar para remodelar a sua cozinha: “O que você realmente quer?”. Por exemplo, você pode querer escrever um programa para automatizar seus dados de backup. Essa é uma descrição geral, mas você precisa de uma lista mais específica das tarefas que você deseja que o programa realize, como:

• Quantas vezes você quer fazer os backups?
• Você quer fazer backup de todos os dados ou apenas dados alterados desde o último backup?
• Quanto tempo você quer manter os backups?

Se você está remodelando sua cozinha, então este é o ponto onde o arquiteto elabora um projeto. O projeto não é a própria cozinha; é o plano que deve ser seguido para a construção da nova cozinha. se você está escrevendo um programa, você começa a construir o contorno do programa, que é semelhante a uma planta. Na verdade, as pessoas que se concentram na análise e concepção de programas são frequentemente chamados de arquitetos de software.

A Pseudo codificação de seus pensamentos

Uma maneira de projetar seu programa é criando um esboço do tipo, usando o que é chamado de pseudo-código. Você escreve um esboço do que o seu programa vai fazer, utilizando as estruturas que você vai precisar usar quando você escrever o programa (como definições de classe e função, as declarações), mas você não deve se preocupar com os detalhes de sintaxe necessárias para escrever código de trabalho.

Pseudo-código tende a assemelhar-se a programas reais, por isso leva menos esforço para converter pseudo-código em código funcionando. quando o processo de pseudo-codificação é concluída, os detalhes são fáceis de escrever.

Depuração

Um bug é um erro em um pedaço do software que faz com que ele funcione de forma inadequada ou retorne resultados incorretos.

Ensine a Velhos Bugs  Novos Truques:

O uso da palavra bug (pau em português) já era comum antes do software ser inventado, por exemplo, Thomas Edison usou em 1878 para descrever problemas com suas invenções. Algumas pessoas vão dizer-lhe, porém, que o termo deriva de um incidente no qual foi encontrado um inseto real que estava causando falhas dentro de um computador no início de 1947.

Embora um bug seja mais velho do que escrever programas, depuração tem sido uma parte inerente da escrita de programas desde que as pessoas começaram a escrever softwares. Um dos primeiros cientistas da computação, Maurice Wilkes, é conhecido por ter dito: “Eu me lembro do momento exato em que eu percebi que uma grande parte da minha vida a partir de então ia ser passar a encontrar erros em meus próprios programas.”.

Escrever um programa complexo é algo como a concepção de um edifício. O arquiteto restringe inclusão do tempo, dinheiro, bom gosto, e os limites estruturais dos materiais. Programação também requer um equilíbrio entre necessidades múltiplas, muitas vezes incluindo o tempo, o dinheiro, a solicitações de recursos de vários grupos de pessoas, e da disponibilidade de quantidades suficientes de cafeína.

Um exemplo de um bom trabalho é com bom humor, o pythonista Tim Peters contribuiu com  19 diretrizes para um bom código Python. Considerado a melhor destilação da filosofia da programação Python:

Bonito é melhor que feio.
Explícito é melhor que implícito.
Simples é melhor que complexo.
Complexo é melhor que complicado.
Plano é melhor que aninhado.
Esparso é melhor que denso.
Legibilidade conta.
Casos especiais não são especiais o suficiente para quebrar as regras.
Embora praticidade vença a pureza.
Erros nunca devem passar em silêncio.
A menos que explicitamente silenciados.
Diante da ambiguidade, recuse a tentação de adivinhar.
Deve haver um – e preferencialmente só um – modo óbvio para fazer isso.
Apesar de que o caminho pode não ser óbvio à primeira vista, a menos que você seja holandês.
Agora é melhor do que nunca.
Embora nunca é muitas vezes melhor do que agora.
Se a implementação é difícil de explicar, é uma má ideia.
Se a implementação é fácil de explicar, pode ser uma boa ideia.
Namespaces são uma grande ideia – vamos fazer mais desses!

-Tim Peters

Versão original: http://www.python.org/doc/humor/#zen