Alcides Duarte Jr

Introdução Você já se pegou criando structs gigantes com dezenas de parâmetros no construtor? Ou pior: passando "" , 0 ou nil só para “pular” campos opcionais? Pois é — isso é mais comum do que parece. Mas a boa notícia é que existe uma solução simples, elegante e muito usada por desenvolvedores experientes: o Builder Pattern . Neste artigo, você vai entender por que o Builder é o segredo para criar objetos complexos em Golang sem comprometer a legibilidade do seu código. Tudo isso com um exemplo prático e direto ao ponto. Bora entender como deixar seu código mais limpo, fluente e fácil de manter? O que é o Builder Pattern? O Builder é um design pattern criacional que permite a criação de objetos complexos passo a passo. Ele é ideal para cenários em que o construtor tradicional com muitos parâmetros se torna ilegível e difícil de manter. Com o Builder, você consegue: Evitar construtores com dezenas de argumentos Garantir imutabilidade e consistênci...

Introdução Quando desenvolvemos aplicações, frequentemente nos deparamos com a necessidade de garantir que uma determinada estrutura de dados tenha apenas uma instância em todo o sistema. É aí que entra o Design Pattern Singleton . Neste artigo, vamos entender o que é o padrão Singleton, por que ele é tão utilizado e como implementá-lo corretamente usando a linguagem Golang (Go). Tudo de forma prática e direta ao ponto. O que é o Singleton? O Singleton é um padrão de projeto criacional que garante que uma classe tenha apenas uma instância , além de fornecer um ponto global de acesso a essa instância. Esse padrão é útil em casos como: Gerenciamento de conexões de banco de dados Implementação de caches Serviços de logging centralizado Controle de configurações globais Problemas que o Singleton Resolve Sem o Singleton, você corre o risco de: Criar múltiplas instâncias de um objeto que deveria ser único Ter problemas de concorrência e inconsistê...

#------------------------------------------------------------ #   Alcides Duarte Jr #   09-09-18 #   URI - www.urionlinejudge.com.br/judge/pt/runs/add/1012 #------------------------------------------------------------ '''------------------------------------------------------------- Escreva um programa que leia três valores com ponto flutuante de dupla precisão: A, B e C. Em seguida, calcule e mostre: ---------------------------------------------------------------- a) a área do triângulo retângulo que tem A por base e C por altura. b) a área do círculo de raio C. (pi = 3.14159) c) a área do trapézio que tem A e B por bases e C por altura. d) a área do quadrado que tem lado B. e) a área do retângulo que tem lados A e B. -------------------------------------------------------------''' def calcular_area_triangulo(a, c):        return (a*c)/2 def calcular_area_circulo(c):     PI = 3.14159     return PI*c*c def cal...

Como é gostoso aprender algo novo e colocar em prática. Depois de pesquisar sobre preencher e manipular páginas web usando a linguagem Python consegui fazer meu primeiro programa que faz login em uma página aqui da empresa e depois simula um clique no botão. Como eu usei o Python 3.5 a biblioteca  mechanize não dá suporte ainda, então fui pela biblioteca  RoboBrowser . import re from robobrowser import RoboBrowser url = "http://blablabla/" user = "user" password = "pass" #abrir url browser = RoboBrowser(history=True) browser.open(url) #preencher form form = browser.get_form('aspnetFormXX') form['cxtl0091$MainContent$txtUsuario'] = user form['cxtl0091$MainContent$txtPassword'] = password #submit no form browser.submit_form(form) #proxima pagina form2 = browser.get_form('aspnetFormXX') #submit em um botao especifico do form browser.submit_form(form2, submit=form2['cztl0091$MainContent$Button1'])

#------------------------------------------------------------------------ #Escreva uma função 'soma_hipotenusas' que receba como parâmetro um #número inteiro positivo e retorna a soma de todos os inteiros #entre 1 e n que são comprimento da hipotenusa de algum triângulo #retângulo com catetos inteiros. #------------------------------------------------------------------------ def calcular_hipotenusa(a, b):     return ((a*a) + (b*b)) def soma_hipotenusas(n):     c = 1     soma = 0     while (c <= n):         _c = (c*c)               a = 1         b = 1         while (a < n):             while (b < n):                 if (_c == calcular_hipotenusa(a, b)):                     #print(a, " - " ,b , " - " , c)     ...

#------------------------------------------------------------------------ #Escreva a função n_primos que recebe um número inteiro maior ou igual #a 2 como parâmetro e devolve a quantidade de números primos que existem #entre 2 e n (incluindo 2 e, se for o caso, n). #------------------------------------------------------------------------ def ehPrimo(n):     if (n == 2):         return True     elif (n % 2 == 0):         return False     else:         i = 3         while (i <= (n / i)):             if ((n % i) == 0):                 return False             i += 2         return True     return False         def n_primos(n):     if (n < 2):         return 0     elif (n == 2): ...

#------------------------------------------------------------ #Faça um programa em Python que resolva uma equacao de segundo # grau #A fórmula de Bhaskara é um método resolutivo para equações #do segundo grau utilizado para encontrar raízes a partir dos #coeficientes da equação. #A fórmula de Bhaskara é um método resolutivo para equações #do segundo grau cujo nome homenageia o grande matemático #indiano que a demonstrou. # x = (-b +- sqrt(b^2 - 4ac)) / 2a #------------------------------------------------------------ import math print("EQUACAO DE SEGUNDO GRAU") print("ax^2 + bx + c = 0") a = float(input("Digite a variável a: ")) b = float(input("Digite a variável b: ")) c = float(input("Digite a variável c: ")) #calcular discriminante - delta delta = (b**2) - (4*a*c) #print("delta é", delta) #calcular as raizes if (delta < 0): print("esta equação não possui raízes reais") else: if (delta == 0): ...

#------------------------------------------------------------ #Escreva um programa que receba um número natural n na #entrada e imprima n! (fatorial) na saída. #------------------------------------------------------------ n = int(input("Digite o valor de n: ")) fatorial = 1 while (n > 0): fatorial = fatorial * n n -= 1 print(fatorial)

#------------------------------------------------------------ #Escreva um programa que receba um número inteiro positivo na #entrada e verifique se é primo. Se o número for primo, #imprima "primo". Caso contrário, imprima "não primo". #------------------------------------------------------------ n = int(input("Digite um número inteiro: ")) cont = 2 ehNroPrimo = True while (cont < n and ehNroPrimo):     ehNroPrimo = not ((n % cont) == 0)     cont += 1 if (ehNroPrimo):     print("primo") else:     print("não primo")

Extraído do livro:  Padrões de Projeto - Soluções Reutilizáveis de Software Orientado a Objetos - Gof Uma breve descrição relacionada ao uso dos padrões de projeto sobre estas três categorias de sistemas. 1.0 - Programas de Aplicações Se você esta construindo um programa de aplicação tal como um editor de documentos ou uma planilha, então as prioridades mais altas são reutilizabilidade interna, facilidade de manutenção e de extensão. A reutilizabilidade interna garante que você não projete, nem implemente, mais do que necessita. Os padrões de projeto que reduzem dependências podem aumentar a reusabilidade interna. O acoplamento mais fraco aumenta a probabilidade de que uma classe de objetos possa cooperar com várias outras. Por exemplo, quando você elimina dependências de operações específicas, pelo isolamento e encapsulamento de cada operação, torna mais fácil a reutilização de uma operação em contextos diferentes. A mesma coisa também pode acontecer quando você remove de...

Para quem deseja ser um bom programador conhecer os Padrões de Projeto é fundamental no mundo Orientado a Objetos. Mesmo que você goste da programação funcional o mundo OO esta sempre presente. Segue um link bacana. Source Making

Segue um modelo de arquitetura de um projeto que estou trabalhando atualmente. Um modelo baseado em referencias legadas e o bom e velho Struts . Classes Actions (métodos) e Forms (objeto que represente os dados que transitam na tela) para tratar as perspectivas de tela junto as JSP`s e JavaScripts . Onde essas classes são configurados no struts-config.xml.

Um programador para ser bom precisa alem dos conhecimentos técnicos, que são indispensáveis, de uma boa dose de raciocínio lógico e ser criterioso. Observo muitos programadores que sempre têm uma fórmula para resolver os desafios propostos.  Mas que em muitos casos é uma solução ruim e dispendiosa.  No mundo da computação podem existir diversos caminhos para chegar ao mesmo resultado e escolher um caminho exige reflexão e uma boa dose de lógica. 

Vida de programador é assim. Você vira um super pai cheio de filhos. Quem é pai sabe como funciona, não existe dia nem hora para o filho aprontar uma. Alguns são mais comportados e obedientes já outros levam consigo o espírito de revoltado e difícil de lidar. Tenho meu horário fixo de trabalho, mas preciso ficar 24 horas no ar para atender as demandas de meus filhos.  Hoje mesmo recebi mensagens via whatsapp enquanto ainda dormia. Pior ainda quando você adota o filho abandonado. Tem que aprender tudo sobre o mesmo e nem semprre tem tempo hábil para isso. É claro que se trata de uma simples comparação onde coloco sistemas como um filho. Ate ele atingir maturidade o programador passa a viver em pro de seu sistema ou sistemas. Estou virando tio de alguns sistemas.  Ai é bom, o pai esta sempre perto quando a coisa fica feia. Falando em ser tio na sexta-feira precisei ficar de baba de um sobrinho. O gestor resolveu rodar alguns cálculos retroativos que levaram um di...

Nas empresas de grande porte sempre me deparo com componentes legados. Ou seja, desenvolvido dentro da empresa.  E sempre percebo que existem soluções comerciais e algumas open source que resolvem o problema, trazendo a solução de forma mais eficiente.  Baixo custo de aprendizagem e testado em outras empresas, o que traz maturidade ao componente.  Porque empresas que não possuem expertise em TI resolvem desenvolver soluções nesta área? Fazem uma solução cheia de bugs e a equipe vai embora deixando a bomba solta na mão de quem nada tem haver com o pato.

Conta-se uma parábola que certo dia Jesus passeava pela floresta e viu um ratinho desesperado correndo, fugindo de algo. Jesus o interpelou e perguntou por que ele corria assim desesperadamente.  O ratinho foi logo dizendo que fugia do gato, e aproveitou para fazer um pedido e disse: “Senhor, por favor, me transforme em um gato assim minha vida vai ser melhor” e a história conta que Jesus concedeu o pedido e o transformou num gato.

Pelas estimativas da Sun (Oracle), ao longo da vida útil de um código padrão, 20% do esforço será despendido na criação e no teste originais do código, e 80% do esforço na manutenção e nas melhorias subsequentes. Concordar com um conjunto de padrões e ajuda a diminuir o esforço envolvido na fabricação de sistemas. A Sun (Oracle) criou um conjunto de padrões de programação para Java e publicou esses padrões em um documento chamado Convenções de Código Java . Classes e Interfaces : A primeira letra maiúsculas, e depois seguir as regras do formato camelCase .

Comprei este livro já faz alguns meses, e gostei muito, traz muita curiosidade do mundo dos números e da matemática em geral. Para os gênios da matemática, aqueles que curtem um desafio de cálculo, é uma boa pedida. O livro conta algumas história curiosa e muitos desafios e enigmas matemáticos (anagramas, quebra-cabeça, jogos, ), tem até piadas. O autor é uma espécie de colecionador de curiosidades matemáticas, em 2008 já havia lançado um livro chamado  Almanaque das Curiosidades Matemáticas . Existe enigmas que vão desde um nível mais simples, que exija pouco conhecimento, até coisas mais complexas que somente um  nerd  de plantão irá solucionar.

Um poderoso companheiro da Herança  ( saiba mais... )  é o uso de Interfaces . A interface é uma espécie de superclasse 100% abstract que define os métodos que uma subclasse deve suportar, mas não como esse suporte deve ser implementado. Em outras palavras, uma interface é um tipo de contrato que diz o que deve ser implementado e codificado, como essa implementação será feita fica a cargo da subclasse.