DEV Community: Dário Prazeres

Linguagens de Programação não são importantes

Dário Prazeres — Fri, 03 Oct 2025 20:27:29 +0000

Muitos acreditam que dominar várias linguagens de programação é essencial para ser um bom programador ou até mesmo ter o repertório vasto de linguagem é uma grande coisa, mas lembra que o Pato anda, nada e voa mais não faz nada direito. Então será que ser um pato traz mesmo benefício?

Outros até criam comunidade para defender a sua linguagem favorita, assim fica uma grande confusão sempre. Não é muito incomum veres pessoas comparando React Native vs Flutter, C# vs Java assim como brigam para saber entre Windows e Linux qual é melhor, Mas Será que linguagens em sim são realmente importantes ou são apenas ferramentas passageiras?

Desenvolver comunidades é algo realmente incrível e é satisfatório estar em uma comunidade que te abrace e te dá-te certas dicas sobre as tecnologias que estás a aprender. Mas nesse processo esquecemos o que é mais importante além de contribuir para aquela comunidade nos tornamos defensores dela e esquecemos de ensinar/compreender os fundamentos da computação, a logica, a capacidade de resolver problemas e o raciocínio algorítmico.

Linguagens são apenas ferramentas

Desculpa estragar o teu clubismo ou até mesmo fanatismo, mas linguagens são como martelos, chave de fenda ou até mesmo um cerrote. Dependendo de qual é o teu o problema vais estudar uma que te dá a solução que desejas alcançar. Apenas são ferramentas para materializar as tuas ideias e resolver o teu problema.

Invés de brigares qual é a “melhor linguagem de programação” deverias se focar em conceitos, solidificar as bases como estrutura de dados, algoritmos, complexidades, arquitetura de software. Esses conteúdos vão te tornar um profissional melhor, ainda mais no mundo das IA’s em que elas estão a entregar soluções melhores a cada dia, então seria ótimo ter um profissional saber que decisões tomar e porquê.

Paradigmas importam mais que sintaxe

Invés de discutir se uma linguagem tem tipagem forte ou não, deverias procurar entender programação funcional, orientada a objetos, lógica, imperativa do que decorar sintaxe de Python, Java, C# ou C++.

Quem busca dominar os paradigmas consegue migrar facilmente de uma linguagem para outra. Exemplo eu aprendi Orientação objeto com Java foi um paradigma que até aquele momento não estava habituado, mas com estudo e dedicação entendi, anos depois tive que aprender C#, apenas tive que olhar a sintaxe como é feita em C#, em suma entender os paradigmas diminui imenso a curva de aprendizado.

O que o mercado valoriza

Ao olhar para o mercado notas que a habilidade crucial não é o teu nível em Python mas sim a capacidade de solucionar os problemas que elas querem que você resolva. Porque no final do dia elas não se importam muito com a linguagem que usaste, desde que solucionaste os problemas é o mais importante para eles.

O mercado também olha para a tua velocidade em aprender uma determinada linguagem nova, isto mostra que és alguém que entendes de computação e não de Programação apenas, e volto a dizer paradigmas e conceitos são mais importantes do que ter muitas linguagens em teu repertório.

Mas o que fazer…

Apesar dos paradigmas, conceitos, logicas e a tua capacidade de resolver um problema serem importantes, é preciso dominar uma linguagem, por que ela é o meio de expressão do pensamento computacional, esta mesmo linguagem é a forma que você vai usar para materializar as tuas soluções aplicando os paradigmas que sabes sobre computação.

A linguagem não é importante em si, mas é veículo que torna possível a aplicação da logica. E quando sentires que já tens uma boa base solida em conceitos de programação só aí acho que deves aprender uma outra o que facilita o processo

Conclusão

Ao longo da tua carreira notarás que certos projetos rodam melhor em Python outros devem ser feitos em PHP. Chegarás a conclusão de que linguagens são transitórias, o que permanece é a habilidade de pensar computacionalmente. Uma outra interessante que deverias ir atras das respostas é porque a existência de muitas linguagens e porque elas são multiparadigmas e multiplataforma hoje em dia.

A linguagem é a caneta, mas o que importa é a capacidade de escrever.

Deixo aqui um video do Fabio Akita explicando um pouco sobre as Linguagens.

Loops vs Recursividade

Dário Prazeres — Thu, 02 Jan 2025 21:36:26 +0000

Muita das vezes já nos perguntamos quando é a melhor opção entre recursividade e um ciclo de repetição ou loops.
Isso é muito comum, visto que na faculdade aprendemos sobre recursividade mas muita vezes resolvemos com loops invés de colocar uma função recursiva. Ou podemos pensar ao contrário e colocar funções recursivas invés de loop.

E caímos na questão onde devemos usar um ou outro e qual é a complexidade de tempo de um e outro.

Loops ou Estrutura de Repetições

Estrutura de repetição é uma lógica que permite que determinadas instruções dentro dessa estrutura repitam-se até uma determinada condição.
Essas estruturas assim como estruturas de condições são muito importantes para termos um código mais performático e organizado visto que muitas coisas as vezes são repetitivas.

Existem algumas variações da estrutura de repetição em algumas linguagens tais como: for, do...while, while e o foeach.

A complexidade de tempo ou Big O para uma estrutura de repetição depende do número de iterações que realiza esse número é denominado N em que coloca a complexidade de tempo em O(N), se tiveres uma estrutura de repetição dentro de outra torna ela em O(N^2) sendo o quadrado de iterações.

Dependendo muito dessa características podemos ter uma ideia se o nosso esta a ser performático

Recursividade

Recursividade é um termo que pode ser usado para descrever a repetição de um objecto de forma similar à que já foi mostrada. Em outras palavras é chamar a mesma função dentro dela mesma. Esta função é constituída por casos bases e chamadas da própria função que com uma logica especifica que se quer resolver um problema afim de chegar no caso base. Poderemos ver um exemplo mais abaixo.

Loops Vs Recursividade

Para mostrar a diferenças entre loops e recursividade iremos implementar soluções para encontrar números de Fibonacci:

Números de Fibonacci ou também chamado de Sequência de Fibonacci, é uma sequência de números inteiros infinitos, começando normalmente em 0 e 1, na qual o número sucessor corresponde à soma dos dois anteriores, exemplo: 0, 1, 1, 2, 3, 5, 8, 13, 21..

Os códigos foram implementados em c-sharp, console application

Implementação usando um For loop

Console.WriteLine("Digite um numero:");
var numCont = Convert.ToInt16(Console.ReadLine());

int prev1 = 1;
int prev2 = 0;

Console.Write(prev2 + " ");
Console.Write(prev1 + " ");

for (int i = 0; i < numCont; i++)
{
    int newNumber = prev1 + prev2;
    Console.Write(newNumber + " ");
    prev2 = prev1;
    prev1 = newNumber;
}

Criamos duas variáveis para conter os dois números de Fibonacci anteriores e dentro de um loop executamos numCont vezes. Isso faz com que a quanto maior for o número que a sequência irá mostrar mais interações ele vai precisar.

Implementação usando recursividade

public static partial class Program
{
    static int numCont;
    static int count = 2;
    public static void Main(String[] args)
    {
        Console.WriteLine("Digite um numero:");
        numCont = Convert.ToInt16(Console.ReadLine());


        Console.Write(0 + " ");
        Console.Write(1 + " ");
        Fibonacci(1, 0);
    }

    static void Fibonacci(int prev1, int prev2)
    {
        if (count <= numCont)
        {
            int newNum = prev1 + prev2;
            Console.Write(newNum + " ");
            prev2 = prev1;
            prev1 = newNum;
            count += 1;
            Fibonacci(prev1, prev2);
        }
        else
        {
            return;
        }
    }
}

Como vimos no código acima a nossa função primeiro calcula o newNum, que é a soma entre os dois sucessores, depois disso ele faz novas atribuições aos antecessores, prev1 passa a ser o actual newNum e chama a função novamente com os novos dados e esta processo só termina quano a condição count <= numCont for falsa.

Mas se desejamos encontrar um numero em questão, com recursividade iremos aplicar a mesma fórmula que diz que o F(n) = F(n-1) + F(n - 2). Isso se queremos obter o 50º termo temos que calcular a soma entre o 48º e o 49º.

public static partial class Program
{
    static int numCont;
    public static void Main(String[] args)
    {
        Console.WriteLine("Digite o termo que desejas saber:");
        numCont = Convert.ToInt16(Console.ReadLine());

        Console.WriteLine("o numero é " +  Fibonacci(numCont));
    }

    static int Fibonacci(int num)
    {
        if (num <= 1) return num;
        else return Fibonacci(num - 1) + Fibonacci(num - 2);
    }
}

Nota que a função Fibonacci é chamada duas vezes, e sempre que ele entrará nela mesma ela será chamada mais duas vezes possível. Para cálculos com valores inferiores não se verá tanta diferença, mas isso será um grande problema para cálculos com valores grandes fazendo com que cada instrução tenha o dobro do tempo que ela será processado.

O custo será a dobrar porque as funções recursivas terão que chegar no caso base e isso leva uma quantidade de instruções depois disso as funções acima terão que esperar resultados dessas funções e elas irão tratamento novamente.

Em partes o código esta organizado e simples mais isso leva muito tempo para executar o que é uma desvantagem visto que queremos performar e beleza no código.

Conclusão

Podemos resolver um problema com diferentes algoritmos e com vários conceitos seja ele loops ou Recursividade, mas devemos saber o que esperar deste código no nosso projecto visto que pode ter um impacto significativo, tanto de performance quanto de estética.

A recursividade e loops são duas técnicas diferentes que podem ser usadas em algoritmos diferentes. Mas agora já sabemos quem é mais performático.

Referências:
W3Schools

Por onde anda o WPF?

Dário Prazeres — Tue, 03 Dec 2024 23:12:52 +0000

Para quem não sabe o WPF, Windows Presentation Foundation, é uma estrutura de de interface de usuário gratuita e de código aberto para Desktop baseados no Windows. Os aplicativos em WPF são baseados em .Net e são desenvolvidos principalmente usando o C# e XAML.

O XAML ou Extensible Application Markup Language é uma linguagem declarativa XML da Microsoft para inicializar valores e objectos estruturados.

Mas de um tempo para cá a Microsoft tem deixado de mandar as actualizações para o WPF com maior frequência do que antes, qual é a razão dessa situação?

Primeiro devemos saber que o WPF é usando para estruturar UI mais modernas em relação ao WinForms, visto que o Winforms é mais usado para Sistema Windows um pouco mais antigo, mas ainda tem suporte até hoje mas se desejares teres uma interface mais recente e com mais animações o Winforms já não entrega.
Segundo a ideia do WPF foi para ajudar ao desenvolvedor até mais domínio ao controle que ele esta a inserir em seu formulário, a conseguir moldar muitos aspectos que seja do componente na base do próprio código sem muito esforço.
Outro aspecto interessante no WPF é a modernidade em relação as funcionalidades, Suporte em Windows mais recentes como uma renderização elegante e moderna.

Mas algo que é tão bom assim como não esta popular?

Por causa de uma nova tecnologia chamada .NET MAUI. O .NET MAUI agora é a carta coringa da Microsoft como UI para aplicativos Nativos.
Imagine que és um desenvolvedor Desktop e estas a criar uma aplicação Desktop e logo desenvolves, mas a ideia se torna popular que chega até usuários de Mac OS, Linux e até Android (Sendo otimista). Terias que criar códigos para diferentes Sistema operacional e talvez com outras linguagens.

Este é o problema que muitos desenvolvedores .NET vêm se perguntando faz tempo e o .NET MAUI venho responder isso. Podemos dizer que terá uma curva maior de aprendizagem, outro problema do .NET MAUI é a por ser uma tecnologia nova, ainda não tem maturidade para estar como primeira opção.

O cenário mudou um pouco por conta na desaceleração ou mesmo na estagnação de tecnologias como o WPF e Winforms. Isto esta matando o WPF aos poucos.

Mas será que vale a pena estudar WPF ou aplicar em novos projectos?

Essa pergunta é relativa e depende da complexidade do projecto. Imaginamos que o projecto é multiplataformas, não seria sensato desenvolver este projecto em WPF.

Mas se este projecto requisitar coisas específicas (como versões mais antigas do Windows) e nativas apenas do Windows e com uma interface agradável pode usar muito bem WPF.

Uma outra razão que vale a pena continuar ou a começar á estudar WPF é que ele hoje é código aberto, isto ajuda com que a comunidade ajude a melhorar a concertar bugs e desenvolver novas features da tecnologia que amamos e usamos. Para se ter noção a Página do GitHub do WPF contém mais de 1200 issues e mais de 206 Pull Request. Isto é sinônimo de que esta tecnologia esta a ser bem aproveitada para quem ama.

Também por ser um tecnologia madura, existe vários produtos e serviços desenvolvido com ela o que leva a precisar a ter conhecimento dessa tecnologia e também ajudará na resolução de issues.

Conclusão

Apesar do WPF ser moderno e maduro aos olhos de muitos, mas torna-se uma tecnologia antiga para que hoje é o limiar das pessoas e para que hoje é o rumo da Microsoft. Mesmo com esses problemas iremos torcer que a Microsoft possa administrar bem o repositório do WPF afim de termos tais correções em versões mais recente.

What are Embedded Systems?

Dário Prazeres — Sun, 13 Oct 2024 21:13:32 +0000

Versão PT

Embedded systems (or integrated systems) are specialized computing systems designed to perform specific functions within a larger device. They consist of hardware and software dedicated to a predefined task or set of tasks, often with real-time requirements and limited resources.

These systems are commonly used in IoT (Internet of Things), which aims to integrate these systems or devices with the internet.

Today, we have a variety of embedded systems, including:

Smart appliances (like microwaves and refrigerators)
Automobiles (like engine control systems and ABS brakes)
Medical devices (like heart monitors and insulin pumps)
Industrial equipment (like manufacturing robots)
Communication devices (like routers and modems)

As we can see, there are many embedded systems in our daily lives. These systems also include software, as the definition of Embedded Systems indicated; this software is developed using a variety of programming languages.

Here is a list of the most commonly used languages in these systems:

1. C: The most widely used language in embedded systems due to its efficiency, direct hardware control, and support for low-level programming.
Advantages: Precise memory control, high performance, accessibility to hardware-specific libraries.

2. Python: Although not a low-level language, it is used in prototyping embedded systems and in high-level applications on more capable devices like the Raspberry Pi.
Advantages: Ease of use, readability of code, and a wide range of libraries.
Disadvantages: Less control over hardware and less efficient in terms of performance and resource usage.

3. C++: An extension of C with support for object-oriented programming, used in more complex projects that require modularity and abstraction.
Advantages: Allows for more organized and scalable systems without sacrificing much efficiency.

4. Assembly: A low-level language used to program directly to hardware, allowing absolute control over resources.
Advantages: Ideal for extreme performance and memory usage optimizations, but difficult to maintain and develop.
Disadvantages: Highly hardware-dependent, which makes portability between different platforms challenging.

5. Ada: A language oriented towards critical systems, especially used in embedded systems that require high reliability and security (e.g., in aviation and military systems).
Advantages: Strong type checking and robust error detection mechanisms.
There are other languages aimed at system development, such as Java, Rust, and JavaScript. As we saw, the languages used in embedded systems are those that facilitate manipulation of hardware and peripherals.

What are the Practical Applications of These Systems?

These systems are present in our lives; we can say they are like the air we breathe today, from automobiles to data processing. Some areas and examples of use include:

1. Automotive

Engine Control Unit (ECU): Controls engine operation to improve efficiency, reduce emissions, and ensure safety.
Airbags: Embedded systems are responsible for detecting collisions and deploying airbags in fractions of a second.

2. Consumer Electronics

Smartphones: Embedded systems control sensors, cameras, network connections, and basic device functions.
Smart TVs: Process images, run applications, connect to the internet, and play media.

3. IoT Devices (Internet of Things)

Home Automation: Temperature sensors, smart lighting, locks, and thermostats controlled remotely.
Wearables: Smartwatches, fitness bands, and other devices that monitor health and physical activity.
Smart Cities: Traffic sensors, smart street lighting, and air quality monitoring.

There are other areas where these systems are used; this is just a summary of what we can find in the market.

Is It Worth Learning About Embedded Systems?

It is definitely worthwhile to gain knowledge and get involved in this field, but it is more suited for those who are familiar with hardware and want to understand more deeply what really happens beyond the devices. Knowledge in Digital Systems, Registers, Microprocessors, Microcontrollers, and good Electronics will be fundamental for this process.

A good suggestion for starting would be to learn C, but if you already come from a language like Python, learning about embedded systems with Raspberry Pi would greatly facilitate creating various elegant and precise things in the modern world.

What are Embedded Systems?

Dário Prazeres — Sun, 13 Oct 2024 21:13:31 +0000

Versão PT

These systems are commonly used in IoT (Internet of Things), which aims to integrate these systems or devices with the internet.

Today, we have a variety of embedded systems, including:

Smart appliances (like microwaves and refrigerators)
Automobiles (like engine control systems and ABS brakes)
Medical devices (like heart monitors and insulin pumps)
Industrial equipment (like manufacturing robots)
Communication devices (like routers and modems)

Here is a list of the most commonly used languages in these systems:

What are the Practical Applications of These Systems?

These systems are present in our lives; we can say they are like the air we breathe today, from automobiles to data processing. Some areas and examples of use include:

1. Automotive

Engine Control Unit (ECU): Controls engine operation to improve efficiency, reduce emissions, and ensure safety.
Airbags: Embedded systems are responsible for detecting collisions and deploying airbags in fractions of a second.

2. Consumer Electronics

Smartphones: Embedded systems control sensors, cameras, network connections, and basic device functions.
Smart TVs: Process images, run applications, connect to the internet, and play media.

3. IoT Devices (Internet of Things)

Home Automation: Temperature sensors, smart lighting, locks, and thermostats controlled remotely.
Wearables: Smartwatches, fitness bands, and other devices that monitor health and physical activity.
Smart Cities: Traffic sensors, smart street lighting, and air quality monitoring.

There are other areas where these systems are used; this is just a summary of what we can find in the market.

Is It Worth Learning About Embedded Systems?

O que são Sistemas Embarcados?

Dário Prazeres — Sun, 13 Oct 2024 21:03:15 +0000

English Version

Sistemas embarcados (ou sistemas integrados) são sistemas de computação especializados projetados para realizar funções específicas dentro de um dispositivo maior. Eles são compostos por hardware e software dedicados a uma tarefa ou conjunto de tarefas pré-definidas, geralmente com requisitos de tempo real e de recursos limitados.

Esses sistemas estão a ser comumente usados em IoT (Internet Of Things), ou simplesmente internet das coisas. Onde visa integrar esses sistemas ou dispositivos com a internet.

Hoje em dia temos uma variedade de sistemas embarcados que incluem:

Eletrodomésticos inteligentes (como fornos micro-ondas, geladeiras)
Automóveis (como o controle eletrônico do motor, freios ABS)
Dispositivos médicos (monitores cardíacos, bombas de insulina)
Equipamentos industriais (robôs de manufatura)
Dispositivos de comunicação (roteadores, modems)

Como vimos temos vários sistemas embarcados no nosso dia-a-dia, nesses sistemas esta constando também Software como a definição de Sistemas Embarcados mostrou, tais software são realizados com uma variedade de linguagens de programação.

Faremos uma listagem das Linguagens mais usadas nesses sistemas:

1. C: A linguagem mais amplamente utilizada em sistemas embarcados devido à sua eficiência, controle direto de hardware e suporte para programação de baixo nível.
Vantagens: Controle preciso de memória, alta performance, acessibilidade de bibliotecas específicas de hardware.

2. Python: Embora não seja uma linguagem de baixo nível, é usada em protótipos de sistemas embarcados e em aplicações de alto nível em dispositivos com mais capacidade, como Raspberry Pi.
Vantagens: Facilidade de uso, leitura de código e uma vasta gama de bibliotecas.
Desvantagens: Menor controle sobre hardware e menos eficiente em termos de desempenho e uso de recursos.

3. C++ : Extensão do C com suporte para programação orientada a objetos, usada em projetos mais complexos que exigem modularidade e abstração.
Vantagens: Permite a criação de sistemas mais organizados e escaláveis, sem sacrificar muito a eficiência.

4. Assembly : Linguagem de baixo nível usada para programar diretamente o hardware, permitindo controle absoluto sobre os recursos.
Vantagens: Ideal para otimizações extremas de desempenho e uso de memória, mas difícil de manter e desenvolver.
Desvantagens: Muito dependente do hardware, o que dificulta a portabilidade entre diferentes plataformas.

5. Ada: Uma linguagem orientada a sistemas críticos, especialmente usada em sistemas embarcados que exigem alta confiabilidade e segurança (por exemplo, em aviação e sistemas militares).
Vantagens: Forte verificação de tipo e mecanismos robustos de detecção de erros

Existem outras linguagens para que visam o desenvolvimento de sistemas, tais como: Java, Rust e Java Script. Como vimos as linguagens que são usadas nos sistemas embarcados são linguagens que facilitam a manipulação do hardware e dos periféricos.

Quais são aplicações praticas desses sistemas?

Tais sistemas estão em nossas vidas, podemos dizer que é como ar que respiramos hoje em dia desde automóveis á processamento de dados.
Algumas áreas e exemplos de uso:

1. Automotivo

Unidade de Controle do Motor (ECU): Controla o funcionamento do motor para melhorar eficiência, reduzir emissões e garantir segurança.
Airbags: Sistemas embarcados são responsáveis por detectar colisões e acionar os airbags em frações de segundo.

2. Dispositivos Eletrônicos de Consumo

Smartphones: Sistemas embarcados controlam sensores, câmeras, conexões de rede e funções básicas do dispositivo.
Smart TVs: Processam imagens, executam aplicativos, conectam-se à internet e reproduzem mídia.

3. Dispositivos IoT (Internet das Coisas)

Automação Residencial: Sensores de temperatura, iluminação inteligente, fechaduras e termostatos controlados remotamente.
Wearables (dispositivos vestíveis): Relógios inteligentes, pulseiras fitness e outros dispositivos que monitoram saúde e atividade física.
Cidades Inteligentes: Sensores de tráfego, iluminação pública inteligente e monitoramento de qualidade do ar.

Existem outras áreas em que esses sistemas são usados e utilizados este é apenas um resumo do que podemos encontrar no mercado.

Vale a pena aprender sobre sistemas embarcados?

Vale muito a pena muito ter conhecimento e se envolver com essa área, mas esta área é para quem esta mais acostumados com hardware aquele que quer ir mas a fundo sobre o que realmente se passa além dos dispositivos. Conhecimentos como Sistemas Digitais, Registros, Microprocessadores, Microcontroladores e a boa Eletrônica serão fundamentais para este processo.

Uma boa sugestão para começar seria C, mas se já vens de uma linguagem como Python e aprender sobre os sistemas embarcados com Raspberry Pi facilitaria muito na criação de varias coisa elegantes e precisas no mundo moderno.

PHP, O elefante que não cai!

Dário Prazeres — Mon, 07 Oct 2024 22:05:17 +0000

Foto de Ben Griffiths na Unsplash

PHP é uma linguagem amplamente aplaudida e ao mesmo tempo criticando por outros, alguns dizem que ela esta morrendo mas será mesmo, vale a pena tirar tempo e estudar PHP?

PHP

PHP é uma linguagem de programação desenvolvida por Rasmus Lerdorf, nos anos 90, originalmente ela foi desenvolvida para ser uma linguagem server side auxiliando com as tecnologias HTML, CSS e JavaScript para termos websites dinâmicos e interativos. Mas o PHP foi muito abraçado devido ao inicio da expansão da Web e pela compreensão fácil com o Banco de dados MySQL.

O PHP hoje esta na versão 8.3.6, e é uma linguagem que apesar de ter crescido em varias outras formas de sua aplicabilidade. Além de ser amplamente usada em Web também tem ferramentas de criação de aplicações Desktop como, PHP-GTK, é possível desenvolver interfaces gráficas (GUIs) para aplicações desktop, embora essa abordagem seja menos comum.

PHP e a Web

Falar do PHP e não vincular o seu patrimônio na web, é considerado crime. O PHP é uma linguagem que esta presente em 80% das paginas da web, é isso mesmo que leste, 80% isso falando se a web tem pelo menos 1.1 billion, então temos cerca 880 milhões de websites envolvidos o PHP.

Mas por que o Php é tão usado usado?

WordPress e os CRM's: o grande crescimento do Php vem por causa dos CRM que existem feitos com Php o que facilita a vida de muita gente e faz com que ela seja muito usado, virando um em 5 sites consegues encontrar fácil um Site ou blog feito em um CRM PHP.
Comunidade Forte: PHP é uma linguagem com cerca de 30 anos e que nesse processo ela fascinou milhares de pessoas e deu dinheiro para várias pessoas que marcaram as suas vidas. E este vinculo proporcionou muitos apoiantes para esta comunidade do Elefante Azul, visto que o PHP é Open Source, isso muda muita coisa na questão da manutenção, resolução de muitos bugs, gerando vasto suporte em fóruns, tutoriais e repositórios de código.
Frameworks e Ferramentas Maduras: Frameworks populares como Laravel, Symfony e CodeIgniter permitem o desenvolvimento de aplicações web robustas, seguras e escaláveis. Essas ferramentas aumentam a produtividade dos desenvolvedores, fornecendo soluções para muitos problemas comuns, como autenticação, roteamento e manipulação de banco de dados.
Desempenho e Escalabilidade Melhorados: O PHP 7 trouxe um aumento de performance notável em comparação com versões anteriores, tornando-o competitivo em termos de velocidade e eficiência. Combinado com ferramentas de cache, como OPcache, e servidores como Nginx ou Apache, o PHP pode ser otimizado para lidar com grandes volumes de tráfego.
Facilidade de Aprendizado e Uso: O PHP é fácil de aprender para iniciantes, com uma curva de aprendizado relativamente baixa. A simplicidade na sintaxe e a capacidade de ser integrado diretamente em arquivos HTML tornam a criação de páginas dinâmicas muito acessível, e é facilmente integrada com as ferramentas do lado do Cliente.

Algum dia este Elefante vai cair?

Listar os motivos do qual o PHP esta no topo desta árvore é uma tarefa impossível visto que existe muitos fenômenos por traz dela, mas a verdade é absoluta o PHP vai ficar ai durante muito tempo visto que apesar de ser funcional ela também tem entregado algumas coisas que te se pedido.
Hoje a web tem indo por um caminho menos monolítico e mais para micro-serviços, o que pode ser uma desvantagem para o PHP, mas isso é ambíguo e não é absoluta e com certeza o PHP tem se adaptando bem para isso também. Então este elefante não vai cair tão fácil.

Sim, podemos tirar tempo e estudar PHP e valerá muito a pena, visto que tem mercado, mas devemos levar em contas outros fatores para decidirmos investir tempo em alguma coisa, no teu caso investirias tempo?

Como Refatorar Seu Código Com Muitos If-Else? Part 2

Dário Prazeres — Thu, 19 Sep 2024 21:05:11 +0000

Como vimos no post anterior existem várias estrategias de refatorar o codigo quando ele tem muitos If-Else, só para relembrar:

1. Early return
2. Tabelas de decisão
3. Polimorfismo
4. Delegação de funções

Early Return

Early Return: é a abordagem que elimina as outras ramificações e concluído as decisões com retornos imediatos, mesmo se tais condições forem falsas. Como podemos ver:

public class CalculadoraDesconto
{
    public decimal CalculoDesconto(Cliente cliente, Pedido pedido)
    {
        if (cliente.IsPremium)
        {
            return pedido.QuantiaTotal > 100 ? pedido.QuantiaTotal * 0.1m : pedido.QuantiaTotal * 0.05m;
        }
        else
        {
            return pedido.QuantiaTotal > 200 ? pedido.QuantiaTotal * 0.15m : pedido.QuantiaTotal * 0.1m;
        }
    }
}

Acima temos uma função com a capacidade de fazer um retorno rápido usando operador ternário, agora veremos o cálculo da Complexidade Ciclomática:

Analise: temos 3 pontos de decisão:

if (cliente.IsPremium) (1 decisão),
pedido.QuantiaTotal > 100 (dentro do primeiro if),
pedido.QuantiaTotal > 200 (dentro do else).

Cálculo:
N = 3
E = 6
P = 1
M = E - N + 2P
M = 6 - (3) + 2(1) = 5

Tabelas de Decisão

Tabelas de decisão é uma técnica usada para simplificar a lógica condicional em código, especialmente quando se tem muitos if-else. Elas ajudam a mapear entradas para saídas, eliminando a necessidade de escrever várias condições aninhadas.

public class CalculadoraDesconto
{
    public decimal CalculoDesconto(Cliente cliente, Pedido pedido)
    {
        decimal descontoPercentual = ObterDescontoPercentual(cliente.IsPremium, pedido.QuantiaTotal);
        return pedido.QuantiaTotal * descontoPercentual;
    }

    private decimal ObterDescontoPercentual(bool isPremium, decimal quantiaTotal)
    {
        if (isPremium)
        {
            return quantiaTotal > 100 ? 0.1m : 0.05m;
        }
        else
        {
            return quantiaTotal > 200 ? 0.15m : 0.1m;
        }
    }
}

Como vimos no código acima, repartiu-se as funções isso para que só depois se fizesse o calculo e não sou acabou por usar a abordagem Early Return na segunda função, o que esteticamente melhorou mas a sua complexidade ciclomática continua a mesma como podemos ver:

Analise: temos 3 pontos de decisão:

if (cliente.IsPremium) (1 decisão),
pedido.QuantiaTotal > 100 (dentro do primeiro if),
pedido.QuantiaTotal > 200 (dentro do else).

Cálculo:
N = 3
E = 6
P = 1
M = E - N + 2P
M = 6 - (3) + 2(1) = 5

Polimorfismo

O polimorfismo é um dos pilares da programação orientada a objetos que permite que diferentes classes respondam de maneiras distintas a uma mesma mensagem (método). Ele possibilita que métodos de mesmo nome, em diferentes classes, tenham comportamentos variados, sem que o código cliente precise saber das diferenças.

Para termos mais detalhes de como funciona veja o exemplo abaixo:

public abstract class Cliente
{
    public abstract decimal CalcularDesconto(Pedido pedido);
}

public class ClientePremium : Cliente
{
    public override decimal CalcularDesconto(Pedido pedido)
    {
        return pedido.QuantiaTotal > 100 ? pedido.QuantiaTotal * 0.1m : pedido.QuantiaTotal * 0.05m;
    }
}

public class ClienteNormal : Cliente
{
    public override decimal CalcularDesconto(Pedido pedido)
    {
        return pedido.QuantiaTotal > 200 ? pedido.QuantiaTotal * 0.15m : pedido.QuantiaTotal * 0.1m;
    }
}

Como vimos criou-se uma classe abstrata chamada Cliente que tem um método chamado CalcularDesconto este método é subscrito nas outras duas funções ClientePremium e ClienteNormal. Esta abordagem permitem fazer cálculos de forma independente e sem condições aninhadas.

Analise: temos 3 pontos de decisão:

Na classe ClientePremium: pedido.QuantiaTotal > 100 (1 decisão),
Na classeClienteNormal: pedido.QuantiaTotal > 200 (1 decisão).

Cálculo:
N = 1
E = 2
P = 1
M = E - N + 2P
M = 2 - (1) + 2(1) = 3

Esta abordagem requer mais organização por outro lado esta abordagem é mais propensa a escalabilidade. Sem falar que a Complexidade ciclomática é muito inferior que as duas anteriores.

Funções Delegadas

Funções Delegadas (ou simplesmente Delegates) é um conceito de programação que permite tratar métodos como objetos. Em linguagens como C#, um delegate é uma referência a um método e pode ser passado como argumento para outras funções, armazenado em variáveis ou retornado de funções, tornando o código mais flexível e modular.

public class CalculadoraDesconto
{
    private Func<Pedido, decimal> ObterCalculoDesconto(Cliente cliente)
    {
        if (cliente.IsPremium)
        {
            return pedido => pedido.QuantiaTotal > 100 ? pedido.QuantiaTotal * 0.1m : pedido.QuantiaTotal * 0.05m;
        }
        else
        {
            return pedido => pedido.QuantiaTotal > 200 ? pedido.QuantiaTotal * 0.15m : pedido.QuantiaTotal * 0.1m;
        }
    }

    public decimal CalculoDesconto(Cliente cliente, Pedido pedido)
    {
        var calcularDesconto = ObterCalculoDesconto(cliente);
        return calcularDesconto(pedido);
    }
}

Analise: temos 3 pontos de decisão:

if (cliente.IsPremium) (1 decisão),
Dentro do retorno da função delegada, há outra decisão para pedido.QuantiaTotal.

Cálculo:
N = 2
E = 4
P = 1
M = E - N + 2P
M = 4 - (2) + 2(1) = 4

Conclusão

Algumas das complexidades ciclomáticas tiveram valores diferentes, umas iguais ao if-else aninhado e outras muito inferiores, não é regra mais isso dependerá muito do exercício que estas criar e levarás em conta a melhor abordagem.

Podemos ver que a complexidade ciclomatíca ajuda muito analisar as abordagens e hoje já existem softwares que verificam esta complexidade. Como programador será difícil as vezes de verificar se este é a melhor forma de fazer, mas convenhamos de que códigos com muitos If-elses não são agradáveis de se ver por mais que esta a funcionar e que quando iremos refatorar será como pisar em ovos. Treine até o ponto de teres olho clinico de analisar a melhor via para ti e para os que poderão mexer nesse código.

Como Refatorar Seu Código Com Muitos If-Else? Part 1

Dário Prazeres — Wed, 18 Sep 2024 21:54:14 +0000

Já olhou para o seu código e notou muitos if...else if...else, e se perguntaste como posso resolver isso de forma mais elegante?

Todos sabemos que a estrutura de condição é algo que esta presente em 99,99% de todos os códigos, mas as vezes nos perguntamos se realmente tais estruturas deveriam ser implementada deste jeito, as vezes de forma imediata acabamos por não pensar em outras formas que seriam mais elegante para o nosso código (confesso que já fiz e as vezes faço).

Mas o que é Ifs e Else?

If's e Elses como digo, são na verdade estruturas de condições. Tais estruturas permitem a escolha de um grupo de ações e estruturas que serão executados, quando certa condição é verdadeira.

if(BomHumor == true)
{
   Console.WriteLine("Bom dia!");
}else
{
   Console.WriteLine("Quero Café!");
}

Complexidade ciclomática

A solução está em entender sobre a complexidade ciclomática do seu código, o que lhe permitirá saber quais estruturas e padrões deverás usar. Mas o que é a Complexidade Ciclomática?

A complexidade ciclomática é uma métrica de software que indica a complexidade de um programa de computador com base na estrutura do seu código-fonte. Foi desenvolvida por Thomas J. McCabe em 1976 e é frequentemente usada para avaliar a facilidade de manutenção e sustentabilidade de um programa. A complexidade ciclomática ajuda a identificar partes do código que podem ser difíceis de entender e manter.

A complexidade ciclomática é calculada contando o número de caminhos independentes no código, o que está relacionado ao grau de aninhamento e às estruturas de controle de fluxo, como condicionais (if, else), loops (for, while), e switches (switch-case). A fórmula para calcular a complexidade ciclomática é a seguinte:
M = E - N + 2P
onde:

M é a complexidade ciclomática.
E é o número de arestas no grafo de controle de fluxo.
N é o número de nós no grafo de controle de fluxo.
P é o número de componentes conectados (como número de partes independentes do código).

Depois de falarmos tanto vamos para um exemplo em C# que usaremos o Padrão de Estratégia(falaremos em outra ocasião com mais detalhes):

public class CalculadoraDesconto
{
    public decimal CalculoDesconto(Cliente cliente, Pedido pedido)
    {
        decimal desconto = 0;

        if (cliente.IsPremium)
        {
            if (pedido.QuantiaTotal > 100)
            {
                desconto = pedido.QuantiaTotal * 0.1m;
            }
            else
            {
                desconto = pedido.QuantiaTotal * 0.05m;
            }
        }
        else
        {
            if (pedido.QuantiaTotal > 200)
            {
                desconto = pedido.QuantiaTotal * 0.15m;
            }
            else
            {
                desconto = pedido.QuantiaTotal * 0.1m;
            }
        }

        return desconto;
    }
}

Nesse exemplo temos uma classe que calcula o desconto de um cliente normal e um premium e isso em função do seu pagamento "QuantiaTotal".

Vamos aplicar a mesma fórmula para calcular a complexidade ciclomática:

Número de nós (N): Neste código, temos os seguintes pontos de decisão:

A primeira decisão, que verifica se o cliente é premium.
A segunda decisão, que verifica se o valor total da ordem é maior que 100.
A terceira decisão, que verifica se o valor total da ordem é maior que 200.

Número de arestas (E): O número de arestas no grafo de controle de fluxo é igual ao número de transições entre os pontos de decisão. Cada ponto de decisão cria dois caminhos (um verdadeiro e outro falso), exceto o primeiro ponto de decisão que cria apenas um caminho. Portanto:

A primeira decisão cria 2 caminhos.
A segunda decisão cria 2 caminhos.
A terceira decisão cria 2 caminhos.

Número de componentes (P): Este código tem um único componente, pois não há partes desconectadas no fluxo de controle.
M = E - N + 2P
M = (2 + 2 + 2) - (3) + 2(1) = 6 - 3 + 2 = 5

A complexidade ciclomática do código é 5. Isso significa que o código tem 5 caminhos independentes possíveis, o que indica um nível moderado de complexidade. Manter a complexidade ciclomática baixa é importante para facilitar a manutenção e os testes do código.

Como vimos no exemplo acima temos uma complexidade de 5, o que não é um caso de insatisfação. Mas ainda não respondemos a pergunta "Como Diminuir os Ifs e elses?"

Como Diminuir os ifs e elses?
Existem várias formas de fazer isso, levando em conta a tua disposição e o tempo de entrega do projecto. Falaremos de 4 estratégias, mas tais estratégias são muito abrangentes.

1. Early return: Elimina ramificações desnecessárias.
2. Tabelas de decisão: Substitui condições por dicionários ou regras.
3. Polimorfismo: Divide a lógica por tipo de cliente.
4. Delegação de funções: Encapsula a lógica de desconto, tornando o código mais modular.

Descreveremos cada estratégia no próximo post, e será apresentados código moldados do exemplo acima.
Parte 2

Algumas linguagens estão a morrer!?

Dário Prazeres — Mon, 16 Sep 2024 21:18:01 +0000

Se colocares no Google 'Linguagens de Programação' a quantidade de resultado serão sempre as linguagens mais populares como: C#, Java Script, Python e Java. (E mesmo não sendo da área muitos acabam por conhecer).

Pela popularidade vale muito a pena aprender sobre tais linguagens, visto que são linguagens com uma grande quantidade de oferta no mercado.

Mas como tudo para chegar onde estamos e nas novas linguagens tudo passou por um processo, e com a popularização das IA's fica ainda mais difícil pensar em estudar linguagens mais antigas.

Algumas linguagens estão mesmo a morrer?

Logo em primeira instância a resposta é sim. O que faz uma linguagem morrer é a quantidade de oferta por ela e de quantas pessoas usam ela para fazer seus projetos.

Mas isso até um certo ponto chega a ser uma vantagem para aquela pessoa que deposita tempo para estudar tais linguagens, mas apesar disso ainda existe a barreira de encontrar projetos que realmente precisam de alguém para tal linguagem.

Faz sentido um iniciante estudar tais linguagens

Meio complicado começar com tais linguagens, visto que quem estudam uma linguagem a tendência é estar á ganhar com essa ferramenta, mas estudando tais linguagens chega a ser uma barreira para entrar de forma rápida no mercado. Ao longo prazo se fores um programador mais experiente, traria mais credibilidade embora que existe muitas coisas que o levariam a estudar.

Para classificar tais linguagens iremos analisar o tempo de criação e a quantidade de usuários. Como base para esta analise foi usado o Stack Overflow Survey 2023

Linguagens como:

Assembly (1950s)
VBA (1993)
Pascal (1970)
F# (2005)
Delphi (1995)
Objective-C (1984)

Estes são alguns exemplos de linguagens que são antigas e que têm poucos usuários hoje em dia. Mas não quer dizer que elas não resolvem problemas e muito menos que deixaram de ser úteis. Por exemplo o F# e o VBA apesar de terem poucos usuários elas dão soluções para muitos programadores hoje em dia.

Por outro lado, muitas linguagens não são populares devido à falta de visibilidade, e, além disso, a curva de aprendizado pode ser muito acentuada. No entanto, isso não acontece com Java, pelo que parece. Então, vale a pena aprender?

Vale a pena gastar tempo em linguagens com pouco mercado e muito antigas?

Primeiramente esta é uma decisão pessoal, eu mesmo tive que estudar Assembly para fazer um trabalho escolar. o que deves levar em conta é o que desejas fazer com a tal linguagem, que projetos queres estar associado? Tens um projeto legado que precisas dar continuidade?
Apesar da tecnologia e os usuários serem poucos muitas linguagens recebem manutenção da comunidade e seus amados usuários que não deixam ela morrer. Então enquanto a ver pessoa a programar naquela linguagem ela não morrerá.

O que é Open Source?

Dário Prazeres — Sun, 15 Sep 2024 19:00:33 +0000

Open Source (Código Aberto) é um modelo de desenvolvimento de software em que o código-fonte é disponibilizado publicamente para que qualquer pessoa possa visualizar, modificar e distribuir. Ao contrário do software proprietário, onde o código é fechado e controlado por uma única entidade, o software open source promove a colaboração e a transparência, permitindo que desenvolvedores contribuam para melhorar o código ou adaptem-no para suas próprias necessidades.

Qual a diferença entre Open Source e Free Code?

A principal diferença entre open source (código aberto) e free code (código livre) está em como cada termo aborda o uso e a distribuição do software, embora muitas vezes eles sejam usados de forma intercambiável. Veja as distinções:

Open Source (Código Aberto):
- Focado na disponibilização do código-fonte para qualquer pessoa, permitindo que ele seja estudado, modificado e redistribuído.
- O conceito de open source está mais ligado ao lado prático e colaborativo do desenvolvimento, destacando os benefícios técnicos de compartilhar e aprimorar software de forma colaborativa.
- Há uma ênfase maior em licenças que promovem a colaboração e o desenvolvimento sustentável (ex.: Licença MIT, Apache, GPL).
Free Code (Código Livre):
- Baseia-se na ideia de liberdade, promovida pelo movimento de software livre (Free Software Foundation). O termo "livre" refere-se à liberdade de usar, estudar, modificar e compartilhar o software, não ao preço.
- O software livre segue as "quatro liberdades" definidas pela Free Software Foundation: (1) liberdade de usar o software para qualquer propósito, (2) liberdade de estudar como o programa funciona, (3) liberdade de distribuir cópias e (4) liberdade de modificar e distribuir suas melhorias.
- Embora seja "livre", o software pode ou não ser gratuito, mas a questão central é garantir a liberdade do usuário em controlar o software.

Em resumo, open source enfatiza a colaboração e o aprimoramento técnico, enquanto free code coloca um foco maior nas liberdades e direitos dos usuários em relação ao software.

Exemplos de Open Source:

Linux - Um dos sistemas operacionais mais populares, utilizado em servidores e dispositivos móveis (como o Android). O código-fonte do Linux é aberto e está disponível para qualquer pessoa contribuir.
Apache HTTP Server - Um dos servidores web mais utilizados no mundo, também desenvolvido e mantido pela comunidade open source.
MySQL - Um sistema de gerenciamento de banco de dados amplamente utilizado, especialmente em aplicações web.
Blender - Software de modelagem e animação 3D utilizado em várias indústrias, de filmes a videogames.

Exemplos de Free Software:

GNU Compiler Collection (GCC) - Um compilador para várias linguagens de programação, desenvolvido como parte do projeto GNU, que adere aos princípios do software livre.
LibreOffice - Um conjunto de aplicativos de escritório que inclui editores de texto, planilhas, apresentações, e muito mais. É totalmente livre e permite modificação e redistribuição.
VLC media player(VideoLAN Client) - é um software reprodutor de mídia portátil , multiplataforma, gratuito e de código aberto e servidor de streaming de mídia desenvolvido pelo projeto VideoLAN.
Firefox - Embora seja um projeto de código aberto, também segue os princípios do software livre, oferecendo um navegador web com liberdade para modificação e distribuição.

Como as Empresas que distribuem e desenvolvem ganham com esses softwares?

Parece ser uma pergunta que não seja relevante, mas manter programadores á desenvolver certos projectos requer custos e a empresa para se manter no mercado precisa de valores e investimentos.

Quando a empresa abre o código para um determinado software algumas pessoas que têm conhecimento na área ajudam a desenvolver tais softwares em troca de nada algumas vezes ou por que este software ajuda muito eles, mas vamos no que interessa e ver como algumas empresas ganham dinheiro com esses softwares.

Serviços e Suporte Técnico Exemplo: Empresas como Red Hat (Linux) e Canonical (Ubuntu) oferecem suporte técnico, serviços de consultoria e manutenção para organizações que utilizam seus sistemas. Como funciona: Embora o software seja gratuito, muitas empresas preferem pagar por suporte especializado, que inclui ajuda na instalação, configuração, solução de problemas e manutenção do software.
Modelos de Negócio Freemium Exemplo: GitLab e Elastic oferecem uma versão open source gratuita do software, mas cobram por funcionalidades adicionais em versões empresariais (como segurança aprimorada ou maior capacidade de escala). Como funciona: A versão básica do software é gratuita, mas as funcionalidades premium, serviços de hospedagem ou integração com outras ferramentas podem ter um custo.
Hospedagem e Infraestrutura Exemplo: Empresas como GitHub e Automattic (que desenvolve o WordPress) oferecem serviços de hospedagem e infraestrutura para projetos open source. Como funciona: Embora o software seja gratuito para baixar e utilizar, as empresas podem cobrar por serviços de hospedagem, backup e manutenção de servidores, oferecendo mais conveniência e escalabilidade.
Consultoria e Customização Exemplo: Muitas empresas especializadas em software livre, como a SUSE (distribuição Linux), ganham dinheiro oferecendo consultoria e customizações específicas para as necessidades de seus clientes. Como funciona: Grandes empresas muitas vezes precisam de soluções personalizadas ou integrações específicas, e estão dispostas a pagar por desenvolvedores experientes que possam fazer essas modificações no software open source.
Licenciamento Dual Exemplo: MySQL usa um modelo de licenciamento dual, onde o software é oferecido sob uma licença GPL (livre), mas as empresas que desejam incorporar MySQL em software proprietário precisam pagar por uma licença comercial. Como funciona: Empresas oferecem o software sob uma licença open source para a comunidade, mas cobram por uma licença comercial se o cliente quiser utilizar o software de forma fechada ou em produtos que não sejam open source.
Marketplaces e Parcerias Exemplo: Empresas como Red Hat e Canonical mantêm parcerias com provedores de nuvem como Amazon AWS, Microsoft Azure e Google Cloud para oferecer pacotes otimizados de software open source. Como funciona: Elas recebem uma parte da receita gerada pelos serviços na nuvem ou pelos pacotes especializados que ajudam a otimizar o uso desses serviços.
Treinamento e Certificação
Exemplo: Red Hat oferece treinamentos e certificações oficiais, como o Red Hat Certified Engineer (RHCE), que tem grande valor no mercado de TI.
Como funciona: As empresas pagam por programas de treinamento e certificação para seus funcionários, o que ajuda a garantir que eles sejam proficientes no uso de software open source.
Publicidade e Patrocínios
Exemplo: Alguns projetos open source são sustentados por doações, patrocínios de empresas e publicidade. O Firefox, por exemplo, é patrocinado pela Mozilla Foundation, que recebe doações e receita publicitária.
Como funciona: Organizações sem fins lucrativos ou projetos pequenos podem ganhar dinheiro através de doações da comunidade ou grandes patrocinadores, além de parcerias com empresas. A titulo de exemplo a Microsoft se tornou um Patrocinador Platina da comunidade Open Source e da Linux Foundation.

Conclusão:
Empresas ganham dinheiro com software open source e free software oferecendo serviços, suporte, customizações, treinamentos e funcionalidades premium, ou cobrando por infraestrutura e integrações. Isso permite que elas mantenham o desenvolvimento contínuo do software, enquanto proporcionam valor adicional para seus clientes.