E por que ele pode custar milhões (ou mesmo vidas)

Se você estuda ou trabalha em alguma área relacionada à tecnologia, é altamente provável – quase certeza – que já se deparou com a expressão “bug” ou com algum verbo “abrasileirado”, como “bugar” ou “bugado”. Mas o que significa exatamente isso?

Considere a seguinte situação: um comando simples, por exemplo programado para imprimir uma mensagem na tela dez vezes, acaba executando indefinidamente, sem qualquer critério de parada. O sistema permanece responsivo, mas o comportamento é claramente incorreto. Trata-se de um erro lógico comum — chamado de loop infinito — e é um exemplo clássico de bug em programação.

Entendendo o conceito de bug

Bugs são falhas no código-fonte que levam um programa a se comportar de forma inesperada ou incorreta. Podem resultar em pequenos transtornos, como uma interface mal formatada, ou em consequências graves, como perda de dados, travamentos do sistema e até riscos à segurança – ou ainda mais graves.

Qualquer pessoa que já tenha escrito código, por mais simples que seja, inevitavelmente se depara com esse tipo de problema.

Mas o que caracteriza, de fato, um bug? E por que eles continuam sendo tão prevalentes mesmo com os avanços nas ferramentas de desenvolvimento e boas práticas de engenharia de software? 

Ao contrário do que muitos pensam, computadores não “pensam” ou “entendem” intenções. Eles fazem exatamente o que mandamos — o problema é que nem sempre mandamos a coisa certa. Eles costumam surgir por erro humano: um código mal projetado, uma lógica mal pensada ou até mesmo por uma simples distração na digitação.

A origem do termo “bug”

A palavra bug (que literalmente significa “inseto” em inglês) foi popularizada pela almirante Grace Hopper em 1947. Durante a manutenção de um computador eletromecânico Mark II, uma mariposa foi encontrada presa em um relé, provocando falhas. O inseto foi cuidadosamente colado no diário de bordo com a legenda: “First actual case of bug being found” (em português, “Primeiro caso real de um bug sendo encontrado”).

A partir de então, o termo passou a ser usado para qualquer tipo de erro ou falha que ocorra em sistemas computacionais, não só de hardware, mas também (e hoje, principalmente) de software.

Primeiro “bug” de computador encontrado – literalmente. Mariposa presa em um relé em um painel do Mark II durante um teste na Universidade de Harvard, em 09 de setembro de 1947. Os operadores que a encontraram a afixaram no livro de registros do computador, com a frase “Primeiro caso real de um bug sendo encontrado”

Os três principais tipos de bug

Os bugs nem sempre se manifestam da mesma forma. Alguns são fáceis de identificar, outros podem passar despercebidos por muito tempo. Os principais tipos incluem:

1. Erros de sintaxe

São falhas na escrita do código — algo como esquecer de fechar aspas, colocar um ponto e vírgula onde não devia (ou não colocar), ou ainda digitar comandos inválidos. A boa notícia? São geralmente detectados imediatamente na hora da compilação ou interpretação, ou mesmo apontados pelo IDE antes mesmo de tentar executar o programa para testá-lo.

2. Erros de execução (runtime)

Esses erros só aparecem quando o programa está rodando. Um exemplo clássico é a tentativa de divisão de um número por zero. O código-fonte parece correto, a aplicação roda normalmente, realiza cálculos com precisão, até que… bum!,  a execução para bruscamente quando uma tentativa de divisão por zero ocorre, podendo ocasionar desde a parada da execução da aplicação até o travamento completo do sistema.

3. Erros semânticos (ou de lógica)

São os mais traiçoeiros e difíceis de detectar. O programa roda, executa tudo sem travar, apresenta a saída para o usuário, mas os resultados estão errados — e às vezes ninguém percebe. Um caso comum ocorre com determinados cálculos matemáticos – o sistema efetua os cálculos solicitados, mas por conta de um bug lógico o resultado apresentado é incorreto, e o usuário pode não perceber o problema.

Esse tipo de erro pode causar grandes transtornos, desde perdas financeiras até acidentes fatais.

Quando um bug deixa de ser só um incômodo

Se você acha que um bug é só um erro inofensivo que causa irritação, pense de novo. Bugs já causaram prejuízos bilionários e, em casos extremos, até mortes.

Citemos alguns exemplos notáveis:

• Nuclear Gandhi: No jogo Sid Meier’s Civilization (1991), um erro no sistema de agressividade das civilizações fazia com que o personagem do pacifista Mahatma Gandhi, inicialmente programado com o menor nível possível de agressividade, se tornasse extremamente beligerante após adoção de políticas democráticas. Devido a um underflow (valor abaixo do mínimo) no valor da variável, seu nível de agressividade era reduzido para um valor negativo, que acabava sendo interpretado como o valor máximo permitido.
  O resultado: um Gandhi obcecado por armas nucleares — um bug icônico da história dos games. Divertido? Sim. Mas ainda um bug.
• Therac-25: Entre 1985 e 1987, um equipamento de radioterapia de nome Therac-25, usado no tratamento de câncer, apresentou falhas críticas causadas por erros de programação em seu sistema de controle. Devido à ausência de verificações adequadas e à confiança excessiva em software, o dispositivo permitia que doses de radiação muito acima do limite seguro fossem aplicadas nos pacientes em tratamento.
  Seis pacientes morreram por exposição acidental a níveis fatais de radiação. 
• Mars Climate Orbiter: Em setembro de 1999, a NASA perdeu contato com a sonda Mars Climate Orbiter pouco antes de sua inserção na órbita do planeta Marte. A falha ocorreu porque um módulo do software produzia dados de impulso na unidade libras-força (sistema imperial), enquanto outro módulo esperava receber esses dados em newtons (sistema métrico).
  A ausência de conversão entre unidades resultou em um erro de trajetória fatal, fazendo com que a sonda descesse demais na atmosfera marciana e fosse destruída. O prejuízo estimado ultrapassou US$ 327 milhões.
• Guitar Hero II: Em 2007, uma atualização lançada para o jogo Guitar Hero II em sua versão para o console Xbox 360 causou problemas sérios de estabilidade em diversos aparelhos. Alguns dispositivos passaram a apresentar falhas críticas após a atualização, incluindo travamentos frequentes e, em muitos casos, o temido “Red Ring of Death” (Anel Vermelho da Morte) — um erro fatal de hardware que inutilizava o console. Embora o bug fosse de software, seu impacto foi sentido no hardware, resultando em muitas unidades defeituosas.

Máquina para tratamento de câncer Therac-25

Como lidar com bugs: a arte da depuração

O processo de encontrar e corrigir bugs é conhecido como debugging (em português, depuração). Ferramentas chamadas depuradores (ou debuggers) ajudam a examinar o código linha por linha, inspecionar variáveis e identificar o ponto exato em que tudo começa a dar errado.

Ambientes de desenvolvimento (IDEs) modernos geralmente vêm com depuradores embutidos, tornando essa tarefa um pouco menos ingrata e mais fácil de realizar.

Prevenção de bugs: manipulação de exceções

Outro recurso fundamental é o tratamento de exceções. Trata-se de prever que algo pode dar errado (como dividir um número por zero em um cálculo) e preparar o programa para lidar com isso de forma antecipada, sem falhar completamente. Linguagens de alto nível como Java, Python e C# têm mecanismos específicos para isso, como os blocos try…catch.

Exemplo em Java:

import java.util.Scanner;
public class Divisao {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);
    System.out.print("Digite o valor de a: ");
    int a = entrada.nextInt();
    System.out.print("Digite o valor de b: ");
    int b = entrada.nextInt();
    int c = a / b; // BUG EM POTENCIAL: pode lançar ArithmeticException se b = 0
    System.out.println("Resultado = " + c);
    entrada.close();
  }
}

Neste exemplo, se o usuário digitar o valor zero ao entrar com o valor de b, será feita uma divisão por zero ao executar o cálculo da variável c. Qualquer outra divisão funcionará, exceto essa.

Ou seja, se b for igual a zero, o programa lançará uma exceção do tipo ArithmeticException e será encerrado abruptamente. Esse é um exemplo clássico de erro de tempo de execução (runtime error), causado por não tratar uma condição excepcional comum.

Como tratar isso? Uma solução é realizar a manipulação dessa exceção, como segue:

import java.util.Scanner;
public class DivisaoSegura {
  public static void main(String[] args) {
    Scanner entrada = new Scanner(System.in);
    System.out.print("Digite o valor de a: ");
    int a = entrada.nextInt();
    System.out.print("Digite o valor de b: ");
    int b = entrada.nextInt();
    try {
      int c = a / b;
      System.out.println("Resultado = " + c);
    }
    catch (ArithmeticException e) {
      System.out.println("Não é possível dividir por zero.");
      System.out.println(e);
    }
    entrada.close();
  }
}

Neste caso a exceção (erro) ArithmeticException foi tratada por meio do uso de um bloco try .. catch, que impedirá o travamento do sistema caso seja fornecido o valor zero à variável b, exibindo em vez disso a mensagem mais amigável “Não é possível dividir por zero” ao usuário..

Testes: prevenindo problemas

A melhor forma de combater bugs é evitá-los desde o início. Testes de software — tanto manuais quanto automatizados — são parte essencial do desenvolvimento. Eles verificam se o programa atende aos requisitos e ajudam a identificar falhas antes que elas possam causar estragos maiores.

Entre os tipos de testes mais comuns estão:

• Testes unitários: verificam o funcionamento de partes específicas do código.
• Testes de integração: checam se os módulos interagem corretamente.
• Testes de sistema: avaliam o sistema como um todo.
• Testes de aceitação: garantem que o software atende ao que o cliente espera.

Bugs no mundo real: onde menos se espera

É importante lembrar que nem só de software vive o mundo dos bugs. Hardware também pode apresentar falhas semelhantes, como erros de projeto em placas, aquecimento excessivo ou falhas elétricas. Mas no fim das contas, tudo parte da mesma raiz: uma falha humana durante a concepção ou implementação de um projeto.

Conclusão: errar é humano, depurar é essencial

Bugs fazem parte da vida de qualquer programador. Não há como evitá-los completamente, mas é possível preveni-los, detectá-los rapidamente e corrigi-los antes que causem problemas sérios.

Com boas práticas de codificação, testes constantes e ferramentas adequadas, dá para dormir mais tranquilo. Ou ao menos, sem sonhar com mariposas voando entre os relés.

Colabore com a Bóson Treinamentos

Ajude o canal adquirindo meus cursos na Udemy:

• Bancos de Dados com MySQL Básico: https://bit.ly/35QdWE4
• Lógica de Programação com Português Estruturado: https://bit.ly/3QKPn22
• Programação em Python do Zero: https://bit.ly/python-boson

Adquira também livros e outros itens na loja da Bóson Treinamentos na Amazon e ajude o canal a se manter e crescer: https://www.amazon.com.br/shop/bosontreinamentos

O post O que é um bug em programação? apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

A sigla API significa Application Programming Interface, ou Interface de Programação de Aplicações, em português. É um conjunto de protocolos, rotinas e ferramentas que permitem que diferentes aplicativos de software se comuniquem entre si.

As APIs agem como intermediárias entre aplicativos de software, permitindo que eles troquem dados e acessem as funcionalidades uns dos outros.

Uma API define um conjunto específico de regras e padrões para a construção de aplicativos de software, especificando como os componentes de software devem interagir uns com os outros.

Ela fornece uma maneira padronizada para diferentes aplicativos acessarem e compartilharem dados e serviços, sem exigir que os desenvolvedores desses aplicativos entendam os detalhes de implementação subjacentes.

Trata-se de uma forma de comunicação entre duas aplicações de computador, que permite a troca de informações por meio de uma rede, como a Internet, usando uma linguagem em comum, que as aplicações conseguem entender.

A empresa ou organização que oferece uma API é chamada de fornecedor da API.

Arquitetura de uma API

Para que serve uma API?

Uma API fornece acesso a dados e serviços que permitem o rápido desenvolvimento de aplicações dos mais variados tipos.

As APIs são amplamente utilizadas no desenvolvimento de software para permitir a integração entre diferentes sistemas de software, facilitar a troca e o compartilhamento de dados e agilizar o processo de desenvolvimento.

Elas são comumente usadas para desenvolver aplicativos da web e móveis, bem como para integrar serviços de terceiros e fontes de dados em aplicativos de software existentes.

Especificações de APIs

As APIs seguem uma especificação, o que na prática significa que:

• O fornecedor da API descreve exatamente as funcionalidades que a API irá oferecer
• O fornecedor também descreve quando as funcionalidade estarão disponíveis, e quando existe a possibilidade de alterações nestas funcionalidades
• O fornecedor da API também por estabelecer restrições técnicas ao uso da API, como limites de uso de banda, quantidade de acessos permitidos por uma aplicação, entre outras.
• Os desenvolvedores (usuários) concordam em usar a API da forma como ela é descrita, seguindo as regras estabelecidas pelo fornecedor da API.

O fornecedor da API pode também:

• Fornecer mecanismos para acesso à API
• Fornecer documentação para ajudar a entender como ela funciona e como usá-la
• Distribuir programas de exemplo para auxiliar os desenvolvedores interessados na API

entre outros.

Algumas APIs são abertas a todos os desenvolvedores, algumas apenas para colaboradores e parceiros e outras são empregadas apenas internamente em uma empresa, por exemplo facilitando a comunicação e colaboração entre os times de desenvolvimento.

Tipos de APIs

As APIs podem ser públicas ou privadas, dependendo do público-alvo e da finalidade.

• APIs públicas são projetadas para serem usadas por desenvolvedores externos e normalmente são disponibilizadas por meio de documentação e portais de desenvolvedores.
• Já as APIs privadas, por outro lado, são usadas dentro de uma organização ou por um conjunto específico de usuários e normalmente não são expostas a desenvolvedores externos.

Exemplos de APIs

Existem muitos exemplos de APIs públicas que são amplamente utilizadas por desenvolvedores para criar aplicativos da web e móveis, bem como para integrar serviços de terceiros e fontes de dados em aplicativos de software existentes. A seguir listo alguns exemplos:

• API do Google Maps: A API do Google Maps permite que os desenvolvedores integrem o Google Maps em seus aplicativos, fornecendo aos usuários recursos como geocodificação, direções e atualizações de tráfego em tempo real.
• API do Twitter: A API do Twitter permite que os desenvolvedores acessem dados e funcionalidades do Twitter, como pesquisar tweets, postar tweets e recuperar informações do usuário.
• API do Facebook: A API do Facebook permite integração da funcionalidade do Facebook em seus aplicativos, como permitir que os usuários façam login com suas contas do Facebook, recuperar informações do usuário e postar nprópria rede social.
• API OpenWeatherMap: A API OpenWeatherMap fornece aos desenvolvedores acesso a dados meteorológicos de todo o mundo, incluindo condições atuais do clima e tempo, previsões e dados históricos.
• API do GitHub: A API do GitHub permite que o acesso às funcionalidades do GitHub, como gerenciamento de repositórios, criação de requisições e recuperação de informações do usuário.

Conclusão

No geral, as APIs desempenham um papel crucial no desenvolvimento de software moderno, permitindo que os desenvolvedores criem aplicativos de software mais robustos e interconectados que podem se comunicar e trocar dados perfeitamente entre si.

O post O que é uma API – Conceitos de Computação apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Aprender novas linguagens de programação é uma tarefa comum na carreira de um desenvolvedor de software. Comumente precisamos usar linguagens diferentes em novos projetos, e algumas áreas da tecnologia se beneficiam do emprego de linguagens específicas, que possuem recursos mais adaptados a determinadas tarefas, como Ciência de Dados, Computação em Nuvem, Automação de Tarefa e outras.

Vamos falar neste artigo sobre uma categoria de linguagens muito especial- as linguagens de programação funcional, que são muito empregadas nas áreas supracitadas, entre outras. Mas antes, vamos entender oque é programação funcional.

O que é Programação Funcional?

Programação funcional é um paradigma na programação no qual podemos executar toda a codificação de uma aplicação usando apenas funções (matemáticas). Ao contrário de paradigmas como a programação orientada a objetos, na programação funcional nos preocupamos apenas com “o que é” em vez de “como” resolver um problema.

Com a programação funcional, aprender novas ferramentas, paradigmas e perspectivas é um processo mais suave e simples e geralmente resulta em um código mais limpo e organizado.

Assim, podemos dizer que linguagens de programação funcional oferecem uma forma “compacta” de programação. Alguns dos recursos oferecidos por essas linguagens incluem o reuso de código e as melhorias de eficiência resultantes, uma legibilidade comparativamente melhor e uma sintaxe bastante simples de depurar.

Além disso, a maioria das linguagens de programação funcionais se integram e trabalham muito bem em tarefas voltadas à ciência de dados.

Vamos às 7 linguagens de programação funcional recomendadas que podem ser úteis em sua carreira como programador, e que valem a pena aprender neste ano.

7 Linguagens de Programação Funcional

1. Clojure

Linguagem de programação de uso geral, compatível com Java Virtual Machine (JVM) e que evita duplicação durante chamadas ao Java. É altamente acessível e interativa para um estilo de programação multithread. Apesar de ser uma linguagem compilada, oferece vários recursos importantes que são suportados em tempo de execução.

Site oficial: https://clojure.org/

2. Elixir

Uma linguagem de programação que suporta concorrência elevada e com baixa latência, é comumente empregada na construção de aplicativos escaláveis ​​e versáteis, com suporte adicional para baixa latência e tolerância a falhas.

Caso você precise projetar um aplicativo para atender a uma grande quantidade de solicitações, Elixir é uma linguagem altamente recomendada, por combinar os melhores recursos e características de linguagens como Clojure, Erlang e Ruby, oferecendo suporte a aplicações com threads múltiplas (multithread).

Site oficial: https://elixir-lang.org/

3. Haskell

O Haskell é uma linguagem de programação funcional avançada, com uma sintaxe declarativa e que pode ser digitada estaticamente. Isso significa que se trata de uma linguagem do tipo de compilação, e essa linguagem fornece mensagens de erro quando a sintaxe está errada, auxiliando muito o processo de debugging do código.

No geral, é empregada na criação de programas de alto desempenho, pois é excelente no quesito otimização. A avaliação dos argumentos facilita a composição abrangente e um melhor controle dos construtos.

Site oficial: https://www.haskell.org/

4. Scala

A linguagem Scala combina recursos tanto de linguagens estáticas quanto de linguagens dinâmicas, sendo usada para criar pipelines de dados e projetos de Big Data. Possuindo um ecossistema gigante de bibliotecas, seus tipos estáticos ajudam a evitar bugs em aplicações complexas.

Muito compatível com Java e a JVM, fornece programação totalmente funcional com funções classificadas como objetos de primeira classe.

Site oficial: https://www.scala-lang.org/

5. Elm

A linguagem Elm, não tão conhecida quanto as outras nessa lista, é mais adequada para a criação de aplicativos Web e também apps HTML, e possui características interessantes como refatoração bastante simplificada, pois ela possui um compilador muito inteligente.

Alimentados por uma estrutura bem arquitetada, os aplicativos em Elm são renderizados muito rapidamente.

A linguagem possui alta interoperabilidade com JavaScript e permite leitura fácil de seu código, podendo ser aplicada a diferentes projetos sem a necessidade de refazer o padrão que o código possuía anteriormente.

Site oficial: https://elm-lang.org/

6. F#

O F# (“F sharp“) é uma linguagem de programação de código aberto e multiplataforma, usada principalmente para escrever código robusto. Trata-se de uma versão funcional da linguagem C# (da Microsoft) e possui uma sintaxe fácil de entender. Possui suporte a correspondência de padrões e programação assíncrona com um conjunto diversificado de tipos de dados.

O F# pode realizar transformação de dados com a ajuda de funções porque segue um paradigma de programação funcional orientado a dados.

Site oficial: https://fsharp.org/

7. Erlang

O Erlang é uma linguagem de programação orientada a processos que emprega usa processos leves. A beleza desta linguagem está em sua capacidade de criar funções que se comunicam entre si.
É considerada a melhor linguagem de programação para aplicações baseadas em mensagens, como por exemplo aplicativos de bate-papo (chat apps), filas de mensagens e aplicativos da blockchain.

Os programas escritos em Erlang acabam sendo altamente responsivos devido ao gerenciamento automatizado de armazenamento e coleta de lixo (garbage collection) da linguagem implementados por processo.

Site oficial: https://www.erlang.org/

Referências

Adaptado de https://www.analyticsinsight.net/top-10-functional-programming-languages-to-know-in-2022/

O post 7 Linguagens de Programação Funcional para aprender em 2022 apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Programação de computadores é uma tarefa que pode ser altamente complexa, cheia de detalhes minuciosos, e altamente propensa a erros. E, no geral, a maioria dos problemas associados a software se refere a código mal escrito, que não segue normas ou padrões, e que foi criado sem o devido cuidado. Em outras palavras, boa parte dos bugs em software são causados pelos próprios desenvolvedores – evidentemente, sem intenção.

Por isso é essencial prestar a máxima atenção ao trabalho realizado quando um software ou sistema de softwares é construído. Muitos problemas podem ser evitados se algumas regras simples forem seguidas desde o início do ciclo de vida de desenvolvimento de um software.

A seguir listamos sete erros comuns que são cometidos com frequência por programadores, e que podem – e devem –  ser evitados desde o início.

Erros comuns ao desenvolver software

1. Não planejar antes de começar a codificar.

Os programas devem ser planejados de antemão – é para isso que serve a fase de análise. A coleta de requisitos, avaliação, pseudocódigos, fluxogramas, são todas ferramentas e técnicas que auxiliam no planejamento de como o software deverá ser desenvolvido na sequência, e que impactam significativamente todo o processo.

Software mal planejado significa, invariavelmente, software que precisará ser reescrito futuramente – e o impacto disso se dá no tempo de desenvolvimento estendido, custo do produto aumentado e, muito comumente, na (má) imagem passada pelo desenvolvedor ou empresa que desenvolve o software aos clientes.

2. Não escrever código limpo.

O código deve ser legível, seguir boas práticas de programação e de padrões de projetos (design patterns), ser organizado e bem-formatado.

Isso inclui usar uma convenção de nomes adequada para variáveis, métodos, eventos, funções, etc.. Os nomes devem expressar a intenção do elemento representado, serem inequívocos, claros e o mais sucintos possível.

Além disso, é importante documentar o código por meio de comentários (mas sem exagero – não escreva um livro dentro do código-fonte!).

Como disse Martin Fowler, autor e desenvolvedor que ajudou a criar o Manifesto para o Desenvolvimento de Software Ágil:

“Qualquer idiota pode escrever um código que um computador consegue entender. Bons programadores escrevem código que os humanos conseguem entender.”

A qualidade do código é sempre fundamental.

Dica de leitura sobre o assunto (link afiliado):

3. Reinventar a roda.

É sempre tentador e desafiador criar nossos próprios algoritmos e bibliotecas, como algoritmos de busca, ordenação, bibliotecas de cálculos e funções variadas. Mas isso, normalmente, é altamente trabalhoso, toma um grande tempo de nosso trabalho, e pode acarretar a inserção de erros variados nos programas que estamos criando. Obviamente precisamos escrever código para nossos projetos, mas se algumas das funcionalidades que necessitamos já existem, na forma de código já pronto, talvez seja uma melhor opção usá-los.

Tente, sempre que possível, usar as bibliotecas e classes escritas por terceiros, pois no geral trata-se de código escrito e otimizado por um grupo de profissionais, cuja probabilidade de apresentar erros é baixa, e assim você poupa um tempo enorme ao não precisar escrever código que já existe pronto e testado.

Além, é claro, da alta probabilidade de seu próprio código apresentar uma série de falhas e bugs.

Reuso de código é a regra!

4. Não realizar testes e não pensar em manipulação de erros no código.

Se o programa funciona para você, não significa que irá funcionar sempre para o usuário – talvez haja alguma falha oculta, ou uma maneira específica de usar a aplicação que traga à tona problemas não previstos. Melhor detectar, tratar e eliminar essas possíveis falhas antes de entregar o produto ao usuário, para evitar problemas mais graves e custosos.

Para tal você deve lançar mão de ao menos duas técnicas: a manipulação de exceções (erros) dentro do código, e a realização de testes de software, dos mais variados tipos (unitários, de integração, etc.).

Pode ser trabalhoso (e aparentemente custoso) escrever rotinas de testes ou de manipulação de exceções, mas muito menos do que corrigir bugs em software já finalizado e em produção (além de ser, no final das contas, mais barato).

5. Somente copiar e adaptar código, sem entender como ele funciona

É extremamente comum, em desenvolvimento de software, que o programador procure trechos de código e algoritmos em sites de busca (como o famoso Stack Overflow), e use os códigos encontrados em sua aplicação, tentando adaptá-los.

Até aí, nenhum problema – afinal, isso é uma espécie de “reuso de código” por meio de compartilhamento. O problema surge quando o programador não procura realmente entender como o código opera – quais as ideias empregadas, técnicas específicas da linguagem, como a lógica foi organizada. Isso impede que o profissional aprenda com o exemplo e seja capaz de, futuramente, escrever por si próprio código sem a necessidade de “copiar e colar”.

Use os códigos compartilhados na Internet à vontade, mas procure aprender como eles foram feitos para que você também seja capaz de escrevê-los – afinal, para que os algoritmos compartilhados existam é necessário que alguém saiba como fazê-los – e esse alguém pode ser você, em algum momento.

6. Não efetuar backup de seus arquivos-fonte.

O backup é de crucial importância, e isso se aplica a quem trabalha com desenvolvimento, e também a quem trabalha com tecnologia em geral, e mesmo a quem não trabalha diretamente com tecnologia, mas usa computadores em suas atividades.

Além de backups (local/nuvem), aprenda a usar sistemas de controle de versão, como o Git ou SVN (Github é um ótimo começo).

Por exemplo, assista ao Minicurso de Git da Bóson Treinamentos em Tecnologia no YouTube para uma introdução ao assunto de controle de versão:

Leitura recomendada (link afiliado):

E por último, mas não menos importante:

7. Não praticar todos os dias (ou quase todos).

Programação é uma atividade prática, que envolve o emprego de uma série de conhecimentos, ferramentas e técnicas, muitas vezes de alta complexidade, e somente a prática constante e focada pode garantir seu aprendizado adequado e o desenvolvimento satisfatório de código funcional, em tempo hábil, e com poucos erros.

Além disso, como em tecnologia em geral o aprendizado é constante, devido à velocidade na qual as tecnologias são desenvolvidas e atualizadas, a necessidade de prática de forma sistemática se torna ainda mais evidente.

Como disse o famoso cientista da computação Alan Turing:

“Programação é uma habilidade adquirida pela prática e pelo exemplo, e não por meio de livros.”

Conclusão

Evitar que erros ocorram durante o desenvolvimento de software é uma tarefa desafiadora, mas há muitas formas de minimizarmos problemas, desde que sejam seguidas algumas recomendações simples, como as apresentadas neste artigo.

O post 7 erros que todo programador deve evitar ao desenvolver software apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Uma pergunta que sempre aparece em todo início de curso de lógica de programação é a indagação “devemos começar a aprender a programar em português ou direto em inglês?“. A ideia por trás desse questionamento é a de que o emprego de ferramentas de aprendizado de programação (para iniciantes) em português (ou em sua língua nativa) pode – ou não – ser mais produtivo do que tentar ensinar programação usando diretamente o idioma inglês (e, talvez, uma linguagem “comum” para tal). 

O tópico rende uma razoável discussão, e é evidente que para algumas pessoas o idioma inglês não é empecilho para o aprendizado de programação, ao passo que outras conseguem absorver melhor os conceitos de lógica envolvidos com mais facilidade se o ensino empregar sua própria língua, como por exemplo usando Portugol (para falantes de português) e aplicações como o VisualG ou o Scratch traduzido.

Um artigo postado por Benjamin Mako Hill no website Copyrighteous (https://mako.cc/copyrighteous/), citado no curso Scratch: Programming for Teachers, da Universidade de Delft, na Holanda (via plataforma edX), discute o assunto, trazendo dados interessantes de pesquisas diversas e de testes de hipóteses levantadas pelos autores do estudo.  A seguir trazemos o artigo na íntegra, traduzido.

Aprendendo a codificar na própria língua

Artigo distribuído sob licença Creative Commons Attribution-ShareAlike.

Publiquei recentemente um artigo com Sayamindu Dasgupta que fornece evidências em apoio à ideia de que as crianças podem aprender a codificar mais rapidamente quando estão programando em sua própria linguagem.

Milhões de jovens de todo o mundo estão aprendendo a programar. Freqüentemente, durante suas experiências de aprendizagem, esses jovens estão usando linguagens de programação baseadas em blocos visuais como Scratch, App Inventor e Code.org Studio.

Em linguagens de programação baseadas em blocos, os codificadores manipulam blocos visuais e encaixáveis ​​que representam construções de código em vez de símbolos textuais e comandos encontrados em linguagens de programação mais tradicionais.

Os símbolos textuais usados ​​em quase todas as linguagens de programação não baseadas em blocos são extraídos do inglês – considere as declarações “if” e os loops “for” como exemplos comuns. Por outro lado, palavras-chave em idiomas baseados em blocos são frequentemente traduzidas para diferentes idiomas humanos.

Por exemplo, dependendo da preferência de idioma do usuário, um conjunto idêntico de instruções de computação no Scratch pode ser representado em muitas línguas humanas diferentes:

Exemplos de um pequeno trecho do código Scratch mostrado em quatro idiomas humanos diferentes: inglês, italiano, norueguês bokmål e alemão.

Embora minha pesquisa com Sayamindu Dasgupta se concentre na aprendizagem, tanto Sayamindu quanto eu trabalhamos em tecnologias de linguagem local antes de voltar para a academia (ambiente escolar). Como resultado, estávamos ambos interessados ​​em como a crescente tradução de linguagens de programação poderia estar tornando mais fácil para crianças que não falam inglês aprenderem a codificar.

Afinal, um grande número de pesquisas em educação mostrou que a educação nos primeiros estágios é mais eficaz quando o ensino é feito na língua que o aluno fala em casa. Com base nessa pesquisa, formulamos a hipótese de que crianças que aprendem a codificar com linguagens de programação baseadas em blocos traduzidas para suas línguas maternas terão melhores resultados de aprendizagem do que crianças que usam os blocos em inglês.

Procuramos testar essa hipótese no Scratch, uma comunidade de aprendizagem informal construída em torno de uma linguagem de programação baseada em blocos. Fomos ajudados pelo fato de o Scratch ser traduzido para vários idiomas e ter um grande número de alunos de todo o mundo.

Para medir o aprendizado, trabalhamos sobre alguns de nossos próprios trabalhos anteriores e analisamos os repertórios de blocos cumulativos dos alunos – semelhante a um vocabulário de código. Ao observar o repertório de blocos cumulativos de um aluno ao longo do tempo, podemos medir a rapidez com que seu vocabulário de código está crescendo.

Usando esses dados, comparamos a taxa de crescimento do repertório de blocos cumulativos entre alunos de países que não falam inglês usando Scratch em inglês e alunos dos mesmos países usando Scratch em seu idioma local. Para identificar quem não fala inglês, consideramos usuários do Scratch que relataram ser provenientes de cinco países que não falam inglês: Portugal, Itália, Brasil, Alemanha e Noruega.

Escolhemos esses cinco países porque cada um deles tem um idioma muito falado que não é o inglês e porque o Scratch está quase totalmente traduzido para esse idioma.

Mesmo depois de controlar uma série de fatores como envolvimento social no site do Scratch, produtividade do usuário e tempo gasto em projetos, descobrimos que os alunos desses países que usam o Scratch em seu idioma local têm uma taxa maior de crescimento cumulativo do repertório de blocos do que seus homólogos usando Scratch em inglês.

Esse crescimento mais rápido ocorreu apesar de ter um repertório de bloqueio inicial mais baixo. O gráfico abaixo mostra nossos resultados para dois alunos “prototípicos” que começam com o mesmo repertório de blocos inicial: um aluno que usa a interface em inglês e um segundo aluno que usa sua língua nativa.

Resumo dos resultados do nosso modelo para dois indivíduos prototípicos.

Nossos resultados estão de acordo com o que as teorias da educação têm a dizer sobre a aprendizagem na própria língua. Nossas descobertas também representam uma boa notícia para designers de linguagens de programação baseadas em bloco que gastaram uma quantidade considerável de esforços para tornar suas linguagens de programação traduzíveis. Também é uma boa notícia para os voluntários que passaram muitas horas traduzindo blocos e interfaces de usuário.

Embora encontremos suporte para nossa hipótese, devemos enfatizar que nossos achados são limitados e incompletos. Por exemplo, porque nos concentramos em estimar as diferenças entre os alunos do Scratch, nossas comparações são entre crianças que conseguiram usar o Scratch com sucesso.

Antes de o Scratch ser traduzido, crianças com pouco conhecimento prático de inglês ou da escrita latina podem não ter sido capazes de usar o Scratch. Por causa da tradução, muitas dessas crianças agora são capazes de aprender a codificar.

Referências

“Learning to Code in One’s Own Language” – https://mako.cc/copyrighteous/scratch-localization-and-learning

O post Aprender a programar em sua própria língua ou em inglês – o que é melhor? apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Programação Orientada a Objetos – POO (Object-Oriented Programming – OOP) é um paradigma de programação que usa tipos de dados personalizados. Em vez de operar apenas com tipos de dados primitivos, podemos construir novos tipos de dados, conforme nossa necessidade.

Esses novos tipos de dados, que chamamos de classes, podem conter estruturas semelhantes a funções, denominadas métodos, e variáveis internas, chamadas de atributos. As classes dão origem a objetos, em um processo denominado instanciação.

Os objetos são os “blocos de construção” de software na OO.

Vantagens da Orientação a Objetos

• Fornece uma estrutura modular para a construção de programas
• Objetos podem ser reutilizados em aplicações diferentes
• O software se torna mais fácil de manter
• O desenvolvimento é mais rápido, devido ao reuso de código
• Encapsulamento: não é necessário conhecer a implementação interna de um objeto para poder usá-lo

Objeto

Trata-se de uma ocorrência específica de uma classe; é uma “instância de classe”.

Os objetos são a base da OO (Orientação a Objetos).

Os objetos representam entidades do mundo real, como aviões, pessoas, contas correntes, etc., mas também podem representar outros conceitos, como gráficos (círculos, quadrados, cones, esferas, etc.)

Um objeto possui características próprias (atributos) e executa determinadas ações (métodos), sendo esses atributos e métodos provenientes da classe que origina o objeto.

Abstração

Abstrair significa selecionar aspectos específicos de um problema a ser analisado, deixando de lado outros aspectos. É a  representação de uma entidade do mundo real na forma de idéias.

As entidades abstraídas podem se comunicar entre si, por meio da troca de Mensagens.

De acordo com o autor Correia (2006):

“Pelo princípio da abstração, nós isolamos os objetos que queremos representar do ambiente complexo em que se situam, e nesses objetos representamos somente as características que são relevantes para o problema em questão”.

Mensagens

Os objetos se comunicam a partir da troca de mensagens.

Uma mensagem é um sinal enviado de um objeto a outro, o qual requisita um serviço, usando uma operação programada no objeto chamado. Por exemplo, para que um objeto execute um método, é necessário enviar a este objeto uma mensagem solicitando a execução do método desejado.

As mensagens somente ocorrem entre objetos que possuem uma Associação.

As mensagens também são programadas. Quando uma mensagem é recebida, uma operação é invocada no objeto chamado.

Há vários formatos de mensagens: procedures (subs e functions), passagem de sinais entre threads, acionamento de eventos, etc.

O que são Classes

Uma Classe é uma coleção de objetos que são descritos com os mesmos atributos e as mesmas operações. Uma classe representa uma ideia ou conceito e classifica objetos que tenham propriedades similares.

As classes são os blocos de construção mais importantes dos sistemas orientados a objetos, e devem possuir responsabilidades bem definidas dentro da aplicação.

Uma classe é um tipo personalizado de dados.

Desta forma, uma classe é um tipo abstrato de dados, um “molde” para a criação de objetos. Cada classe criada se torna um novo tipo disponível para declarar variáveis e criar objetos

Por convenção, começamos o nome de uma classe com letra maiúscula, e capitalizamos cada palavra subsequente que o compuser.

As classes representam os blocos de construção mais importantes dos sistemas orientados a objetos, e devem possuir responsabilidades bem definidas dentro da aplicação.

Uma classe é como se fosse um tipo abstrato de dados, um “molde” para a criação de objetos.

Um objeto é, portanto, um “Instância de uma Classe”

As classes possuem atributos e métodos.  Atributos são características da classe, que são comuns a todos os objetos derivados, e que podem apresentar valores diversos. Já os Métodos são as operações possíveis em uma classe (nos objetos instanciados a partir dela).

Atributo de Classe

Ou Propriedade: Característica particular de uma ocorrência de uma classe, como por exemplo o nome e a idade de uma pessoa.

Existem dois tipos principais de propriedades:

• Estáticas: Mantém o mesmo valor durante toda a sua existência. Por exemplo, a data de nascimento de uma pessoa é uma propriedade estática, pois mantém o mesmo valor durante toda a existência do objeto instanciado.
• Dinâmicas: Podem ter valores que variam com o passar do tempo. A idade de uma pessoa pode ser considerada um atributo dinâmico, pois pode variar ao longo do tempo.

Método

É a lógica contida em uma classe para atribuir-lhe comportamentos. São as funções e procedimentos contidos na classe.

O ato de invocar um método é a passagem de mensagens para o objeto.

Toda classe possui um método especial chamado de método construtor, que inicializa o objeto instanciado.

As classes também usam métodos destruidores para finalizar os objetos após seu uso.

Um método é uma sequência de declarações (comandos) que possui um nome de identificação. É similar a uma função ou procedimento.

Um método possui um nome e um corpo onde ficam os comandos que serão executados quando o método for chamado, e também podem receber dados para processamento (parâmetros) e retornar informações.

Os métodos são a forma principal de passagem de mensagens entre objetos. Um método deve executar sempre uma operação única. Os métodos também precisam ter um tipo de retorno, que pode ser um tipo de valor, de referência ou ainda void (não retornam valor).

Classe – Notação UML para representação

A seguir temos a forma padrão para representação de uma classe usando um diagrama de classes UML:

Instância de Classe

É o objeto, uma ocorrência específica de uma classe.

As classes originam instâncias sob requisição, no processo denominado Instanciação. O projetista / analista cria a classe. A classe é então usada para criar objetos em tempo de execução.

Veja a seguir um exemplo de criação de classe na linguagem C#. É declarado um atributo da classe Caixa – lado – e um método – Volume():

Herança

Herança, em orientação a objetos, é a capacidade de um novo objeto tomar atributos e operações de um objeto existente.

Assim, podemos criar classes mais complexas sem que precisemos repetir código.

Aqui, a palavra-chave é Reuso de código, e é uma das metas a se atingir ao desenvolver software. O reuso permite reduzir o esforço dispendido no desenvolvimento de software ao reaproveitarmos códigos de uma classe na criação de outras classes.

A Herança é, portanto,  um conceito extremamente importante em Orientação a Objetos.

Usamos a herança, por exemplo, para evitar repetição ao definirmos classes com características em comum e que são relacionadas entre si.

A herança é um relacionamento entre classes, que permite que uma classe “adquira” os membros (atributos e métodos) de outra classe.

Um exemplo clássico de herança seria a classificação de mamíferos no reino animal.

Homens, Baleias e Gatos são mamíferos, que compartilham muitas características entre si, mas claramente possuem atributos que os diferem uns dos outros.

Como podemos modelar Baleias, Gatos e Humanos em um software?

Podemos criar classes distintas para cada animal, mas essas classes teriam muitos comportamentos (“métodos”) em comum entre eles, como Respirar, Mamar e Reproduzir-se, o que ocasionaria repetição desnecessária de código.

Usamos então Herança para resolver esse problema. Podemos criar uma classe chamada Mamífero que possua as características comuns a todos os animais mamíferos, e então criar as classes Humano, Baleia e Gato herdando essas funcionalidades e também implementando as funcionalidades específicas de cada animal, como Falar, Nadar e Miar.

O quadro a seguir mostra duas classes, Humano e Gato, que herdam os atributos e métodos da superclasse Mamífero, e implementam seus próprios atributos e métodos adicionais: atributos nome e sobrenome e métodos andar() e falar() para a classe Humano, e os atributos raça e nome e métodos andar() e miar() para a classe Gato:

Encapsulamento

Encapsulamento é a combinação de atributos e operações dentro de uma classe, deixando visível apenas o que é necessário para a comunicação entre dois objetos, como por exemplo alguns detalhes da implementação ou ainda a lógica de um método.

O encapsulamento permite ocultar a complexidade do código. Não é necessário entender como a operação funciona para poder utilizá-la. Um exemplo clássico é o de um motorista conduzindo um veículo. O motorista não precisa saber exatamente como um motor funciona internamente para poder dirigir o automóvel – o detalhes da “implementação” do motor ficam ocultos do motorista.

O encapsulamento protege os dados, permitindo o acesso a eles apenas a partir de métodos específicos e autorizados.

Desta forma, os objetos encapsulados podem ser comparados uma caixa preta: conhecemos  asua interface externa, porém não precisamos nos preocupar com o que acontece internamente na caixa.

Encapsulamento – Níveis de Acesso

Há três níveis principais de acesso dos objetos:

• Público
• Privado
• Protegido

Vamos discutir em mais detalhes esses níveis de acesso em uma lição especial sobre o assunto.

Polimorfismo

Uma operação de um objeto qualquer pode assumir vários comportamentos dependendo da chamada recebida, tratando e devolvendo respostas ao chamador.

Poli = Muitos; Morphos = Formas. Portanto, Polimorfismo = “múltiplas formas”.

Portanto, o polimorfismo ocorre quando um objeto tem um comportamento diferente para uma mesma ação. Por exemplo, usando nosso exemplo de classes de animais, nas classes Gato e Humano existe um comportamento (método) em comum: Andar. Porém, cada uma dessas classes implementa o método Andar de forma diferente – os gatos andam em quatro patas, enquanto os humanos andam em duas. Ambos podem percorrer a mesma distância andando, ou seja, executando o método andar, mas o farão de forma diferente entre si.

Então, dependendo de como um método é invocado, seu comportamento será diferente.

Neste artigo publicamos uma pequena introdução à Orientação a Objetos. Nos próximos artigos desta série vamos nos aprofundar nesses assuntos, e apresentar muitos outros conceitos relativos a esse tópico.

O post Conceitos de Programação Orientada a Objetos apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Aprender programação de computadores não é exatamente uma tarefa simples. No geral, é necessário um grande esforço para que um estudante consiga aprender a programar de forma satisfatória, ao longo de um intervalo de tempo que pode variar de vários meses a vários anos.

Além disso, muitas pessoas creem que aprender a programar se resume apenas a aprender a usar uma linguagem de programação. Mas isso está muito longe da verdade! Quando usamos a expressão “Programação de Computadores”, na verdade, o que estamos dizendo é “Desenvolvimento de Sistemas”. Assim, programar vai além de simplesmente aprender Java, JavaScript, C ou outra linguagem qualquer.

Um Desenvolvedor de Sistemas, idealmente, precisa possuir conhecimentos diversos, como:

• Linguagens de programação
• Análise e modelagem de sistemas
• Testes de software
• Trabalhar com ferramentas diversas, como IDEs especializados e compiladores
• Conhecer diversas bibliotecas e frameworks
• Saber trabalhar em equipe – “times”
• Ser autodidata (sim, você vai ter de aprender muita coisa por si só)
• Conhecer teoria de bancos de dados e implementação física
• Gerenciamento de Projetos

Muita coisa não? Se apenas aprender uma linguagem já estava dando trabalho, imagine aprender tudo isso!

Mas vamos com calma. Ninguém disse que é necessário aprender tudo isso de uma vez e em poucos dias. Na verdade, seu aprendizado nesta área da computação será contínuo, e infindável. Você vai estudar e aprender enquanto atuar nessa área. Agora, é claro que, o quanto antes você aprender as disciplinas citadas, melhor será para sua carreira. E como fazer isso, na prática?

Neste post minha ideia é ilustrar algumas técnicas que estudantes da área de desenvolvimento de sistemas podem usar para melhorar seu aprendizado em programação e disciplinas correlatas, do ponto de vista prático. Não pretendo dizer coisas como “você tem de estudar bastante”, ou “não desista, você chega lá”. Isso é, obviamente,  extremamente importante, mas eu já falei a respeito desse aspecto do esforço e da dificuldade de aprendizado neste vídeo da Bóson Treinamentos.

Técnicas de Estudo para Programação

Para aprender de forma mais eficiente e melhorar seus conhecimentos de programação, sugiro as seguintes técnicas e dicas, de acordo com minha própria experiência:

1. Codar ao menos duas horas por dia (de duas a quatro é o ideal) e descansar um dia por semana. Menos do que duas horas é insuficiente para que seja possível estudar um assunto e praticá-lo de forma satisfatória. Mas tome cuidado: estudar por muito tempo em sequência (por exemplo, 10 horas seguidas) também não é muito efetivo, e pode levar a um esgotamento extremamente prejudicial no médio prazo. Tenha parcimônia e respeite seus próprios limites. E não deixe de descansar um dia por semana – aproveite esse dia para fazer outras atividades fora da programação, como passear, ir ao cinema, jogar futebol, ir à praia ou outra coisa divertida e salutar.
2. Escreva MUITO código. Não importa se seu código é bom, se é ruim, feio ou elegante, o que você precisa fazer nesta etapa (como um iniciante) é escrever o máximo de código que você puder. Não importa se você vai escrever algoritmos simples, apenas escreva, teste e depure até que seja trivial para você codar.
3. Fique calmo ao debugar problemas que apareçam em seu código (eles vão aparecer com certeza!) e use os recursos disponíveis na Internet para ajudar a resolvê-los. Se enervar por conta de um código que não funciona como deveria é a melhor forma de não aprender a programar.
4. Quando estiver com dúvidas, e não conseguir resolver um problema por si próprio, não entre em pânico: procure ajuda. Seja em fóruns, grupos de estudos, na escola ou com seus colegas, procure descobrir o que está errado em seu código, e após descobrir o problema, tente consertá-lo sem copiar e colar nenhum código – reescreva seu algoritmo aplicando a solução encontrada – ver dica seguinte.
5. Não “copie e cole” código – se você o fizer, nunca aprenderá realmente a escrever seus próprios algoritmos. Suponha que você tenha encontrado uma solução para um problema em um site da Internet, como um fórum, ou o Stack Overflow. Leia a solução encontrada, procure entender o raciocínio por trás de quem a escreveu, tire dúvidas com as pessoas e, então, tente escrever sua própria solução, sem simplesmente reutilizar a encontrada.
6. Faça pausas regulares a cada 40 minutos a 1 hora para tomar um café, um suco, relaxar, etc, durante uns 5 a 10 minutos (no máximo).
7. Enquanto estiver codificando, fique longe do smartphone, feche o Facebook e não fale com ninguém pelo Whatsapp. Saia das redes sociais (exceto os fóruns de desenvolvedores!). Se concentre no que está fazendo no momento.
8. Escreva programas para vê-los funcionar. Não importa se o código que você escreveu é da melhor qualidade – nesta etapa, o que você precisa é escrever programas que FUNCIONEM, pois assim você saberá que está realmente aprendendo a escrever algoritmos e verá seu trabalho dando frutos, o que é muito motivador. 
9. Quando você conseguir escrever programas que funcionem, aprenda a refatorá-los – reescreva seu código de modo a deixá-lo mais limpo, organizado e eficiente. Desta forma, em pouco tempo você estará escrevendo código elegante e funcional desde o início de um projeto.
10. Use e abuse de Comentários em seu código. Faça esse favor a si mesmo e aos colegas que irão trabalhar com você. Desta forma, você não corre o risco de não se lembrar o que um algoritmo ou trecho de código faz seis meses depois de tê-lo escrito – e poupa o trabalho de analisar código-fonte de forma desnecessária a si e aos membros de seu time de desenvolvimento – ou quem vier depois.
11. Aprenda um pouco sobre áreas relacionadas que citamos anteriormente, como Gerenciamento de Projetos, Testes, Hardware de Computadores, etc., pois esses conhecimentos complementam o estudo de programação e ampliam sua visão para o entendimento e a resolução de problemas. E, principalmente, aprende a ANALISAR problemas antes de tentar escrever códigos para resolvê-los. Se você não entender exatamente a natureza de um problema e suas ramificaç~eos e dependências, como pretende solucioná-lo?
12. Domine um IDE ou editor de códigos. Preferencialmente, um que não tenha demasiados recursos – mas também não é preciso usar somente o bloco de notas ou o editor vi. Algo como os editores Notepad++ ou o Sublime Text são excelentes nessa etapa. Se foque no código, e tente evitar recursos como auto-completar nessa fase de seu aprendizado. Após ter aprendido a usar um IDE, não é má ideia mudar para outro IDE e aprender a usá-lo também.
13. Sempre registre o que você está estudando – e aprendendo. Escreva com usas próprias palavras o que você estudou e aprendeu em um caderno, por exemplo, pois isso ajuda a fixar em sua mente os conceitos e a lembrar deles no longo prazo. Sim, em um caderno, mídia física, fora do computador.
14. Tente ensinar alguém que sabe menos que você. Essa é uma forma excelente de aprender. Inclusive, é uma das famosas técnicas de Richard Feynman para aprender “qualquer coisa” – sobre as quais já falamos no vídeo sobre As Técnicas de Estudo de Richard Feynman.
15. Tutoriais em Vídeo – YouTube, Udemy, CBT Nuggets, etc.; É muito comum assistir a cursos e tutoriais em vídeo atualmente – nós mesmos temos mais de 1200 vídeos publicados no canal da Bóson Treinamentos no YouTube!. Porém, é preciso tomar muito cuidado com essa modalidade de estudo. Quando assistimos a um vídeo sobre determinado assunto, é comum a ilusão de termos aprendido o tópico explicado. Porém, assistir a um vídeo é uma atividade passiva – você precisa treinar o que foi visto para garantir o aprendizado do assunto. Ver alguém falando, por exemplo, sobre estruturas de repetição em Python não significa que você tenha aprendido o assunto – é necessário abrir o IDE e exercitar-se escrevendo e testando códigos e algoritmos, e criando aplicações diversas.
16. Codifique à mão. Escrever algoritmos usando papel e caneta permite aumentar sua proficiência e é um método muito efetivo para aprender a programar-  na verdade, para aprender qualquer coisa. Escrever à mão requer cuidado, precisão e atenção, o que no geral leva a uma maior absorção do conteúdo estudado. Era assim que estudávamos há alguns anos, quando nem sempre tínhamos acesso a computadores em casa. Além disso, muitas entrevistas de emprego incluem testes de escrita de algoritmos – escritos à mão. 
17. Leia livros sobre teoria de desenvolvimento de sistemas e programação de computadores. Não livros sobre como usar as linguagens, mas como funciona o processo de desenvolvimento de software. Aprender a filosofia por trás das tecnologias é realmente muito importante para que você possa adquirir habilidade e proficiência. 
18. Se sua dificuldade for em entender lógica de programação, não hesite em usar uma linguagem visual, mesmo que feita para crianças. Scratch é uma ótima linguagem para esse fim. Algumas pessoas tem mais facilidade de aprender de forma visual, e se esse for seu caso, vá em frente.

E lembre-se sempre: Jamais se compare com os outros. Seu objetivo é aprender a programar bem, e não mensurar o quanto os outros sabem. Não é uma disputa. Se seu colega de sala ou de trabalho conhece muito mais de programação do que você, ou tem muito mais facilidade para aprender, isso não importa. O que importa é o quanto você está aprendendo. Na verdade, ter colegas por perto que saibam muito mais do que nós é muito bom – estar rodeado de pessoas com grande conhecimento é uma ótima forma de crescermos profissionalmente. Olhe para eles como uma inspiração,e  como uma oportunidade de aprender a trabalhar em equipe.

E não tenha pressa. O domínio do conhecimento sobre desenvolvimento de software virá com o devido tempo.

Espero que essas dicas para Aprendizado de Programação possam ser úteis e ajudar os estudantes a melhorar o desempenho em seus estudos e seu trabalho.

Até mais!

O post 18 Dicas para aprendizado de Programação de Computadores apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

Olá pessoal! Neste artigo vou explicar, de forma sucinta, alguns dos principais conceitos presentes na disciplina de Programação Orientação a Objetos. Meu intuito não é o de me aprofundar nesses conceitos, mas sim de apresentá-los inicialmente, como uma espécie de sumário, de modo a apresentar e esclarecer algumas ideias fundamentais da matéria.

Posteriormente vamos nos aprofundar em cada conceito, inclusive com exemplos de aplicações nas linguagens de programação mais comuns da atualidade.

Definição

Programação Orientada a Objetos – POO (Object-Oriented Programming – OOP) é um método de programação (estilo) que usa tipos de dados personalizados. Em vez de operar apenas com tipos de dados primitivos, podemos construir novos tipos de dados, conforme nossa necessidade (necessidade da aplicação).

Esses novos tipos de dados, que chamamos de classes, podem conter estruturas semelhantes a funções, denominadas métodos, e variáveis internas, chamadas de atributos.

As classes são estruturas semelhantes a strucutures e unions, utilizadas em programação estruturada, porém tem características diferenciadas, como:

• Classes possuem suas próprias funções (métodos)
• Podem ter dados privados ou protegidos
• Podem herdar características de outras classes para absorver sua funcionalidade
• Cada classe pode agir como se fosse uma entidade completamente separada do resto do programa

Uma das principais ideias em orientação a objetos é o conceito de Abstração, que consiste em esconder do usuário os detalhes de um processo. Em OOP, o programador (que é o usuário) não precisa conhecer todos os detalhes de implementação intrincados de uma classe, basta que saiba como utilizá-la em seu programa.

Membros de Classe

Existem dois tipos de membros (elementos internos) em uma classe: atributos e métodos.

• Atributos: “Conteineres” onde um objeto armazena dados, de forma similar a Variáveis. Armazenam informações sobre um objeto. Por exemplo, um objeto “Pessoa” pode ter um atributo “Nome” e um atributo “Altura” para armazenar essas duas propriedades de uma pessoa em particular.
• Métodos: São funções e procedimentos vinculados a um objeto, as quais permitem que o objeto realize (ou sofra) ações. Por exemplo, um objeto Pessoa pode ter os métodos “andar()”, “comer()” e “dormir()”, que descrevem como essas ações são realizadas. Note o uso dos parênteses para descrever o nome do método.

Tipos de linguagens OO (Orientadas a Objetos)

Existem, fundamentalmente, dois tipos de linguagens orientadas a objetos:

• OO Suportada: Tratam-se de linguagens procedurais que possuem um componente de programação OO inserido. Como exemplos, podemos citar as linguagens PHP, Visual Basic, COBOL e Objective C.
• OO Pura: São linguagens nativamente orientadas a objetos, como Java, Scala, Smalltalk e C#. Algumas dessas linguagens, como o Java, possuem alguns elementos procedurais disponíveis.

Níveis de acesso

Os níveis de acesso em uma classe determinam a visibilidade de seus componentes (métodos e atributos). Temos três níveis de acesso no geral:

• Público: Elementos acessíveis a todo o código da aplicação, em toda a parte.
• Privado: Um elemento privado pode apenas ser acessado pelo próprio objeto (internamente) ou por funções “amigáveis”.
• Protegido: Um elemento protegido somente é acessível pelo próprio objeto e por objetos herdeiros dele.

Além disso, o acesso pode ser classificado em:

• Acesso em nível de classe (estático): Os membros pertencem ao objeto, e não à instância
• Acesso em nível de instância (não-estático): Os membros pertencem À instância e não ao objeto.

As instâncias não possuem os métodos e atributos estáticos do objeto que representam.

Métodos Construtor e Destrutor

Tratam-se de dois métodos especiais que possuem funções bem-definidas em um objeto.

• Método Construtor: É um método que é executado automaticamente quando uma classe é instanciada (objeto é criado), sendo utilizada normalmente para inicializar determinados atributos do objeto. Pode aceitar parâmetros para criar um objeto de forma personalizada, e permite a manipulação de campos (atributos) estáticos.
• Método Destrutor: Este método é executado automaticamente quando uma instância existente de uma classe (objeto) é destruída (eliminada da memória). Também manipula atributos estáticos.

Setters e Getters

Um Setter é um método especial que permite configurar indiretamente valores dentro de um objeto (atributos). 

Um Getter é outro método especial, usado para obtermos de forma indireta os valores armazenados dentro do objeto.

Ambos previnem o acesso direto à informações privadas do objeto, permitindo o acesso controlado aos dados.

Polimorfismo

O conceito de Polimorfismo é a habilidade em uma linguagem de permitir que múltiplos tipos da dados apareçam e sejam utilizados como outro tipo. Podemos classificar as linguagens de duas formas com relação a tipos de dados:

• Fortemente tipada: Os tipos de dados sempre derivam de um outro tipo.
• Fracamente tipadas: Os tipos de dados são implicitamente polimórficos.

Para que serve o polimorfismo?

• Desenvolvedores não precisam conhecer os tipos de dados (internamente) ao codificar.
• Os tipos de dados serão reconhecidos e manipulados em tempo de execução (processo denominado dynamic binding)
• Tipos diferentes de dados podem compartilhar os mesmos operadores, por meio de um processo chamado de Sobrecarga de Operadores.

Com a sobrecarga de operadores, uma mesma classe pode fornecer múltiplos métodos para manipular diferentes operadores.

O polimorfismo permite, por exemplo, que as funções de atributos ou métodos sejam modificados quando uma classe é criada herdando de outra classe-pai. Esse é um dos pilares da Programação Orientada a Objetos.

Sobrecarga de Métodos

Podemos também sobrecarregar métodos, o que significa que podemos fornecer múltiplos métodos com uma variedade de parâmetros, tornando-os mais genéricos. Por exemplo, podemos ter um método que, ao receber duas strings, as concatena, formando uma terceira, mas se receber dois inteiros realiza sua soma em vez de concatená-los. 

Method Overriding

Este conceito diz respeito à substituição de um método em uma classe por uma função externa, quando de seu uso.

Os métodos que podem ser sobrescritos assim são chamados de Métodos Virtuais.

Recursão aberta

É a habilidade de uma linguagem de programação que permite o acesso a membros de uma instância do objeto. Tipicamente, é usada com palavras-chave específicas e construída em nomes de variáveis.

Por exemplo, temos palavras-chave como this, self, me, que são ponteiros para a instância real na qual eles são utilizados.

É isso aí! Vimos neste tutorial alguns conceitos iniciais importantes para o estudo de Programação Orientada a Objetos.

Na parte 02 deste tutorial vamos tratar de mais conceitos, como Delegates, Namespaces e Encapsulamento, entre outros.

O post Conceitos gerais de Programação Orientada a Objetos – 01 apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.

A Black Duck Software, um provedor de soluções de software open source (OSS) e a  North Bridge, uma empresa de capital de risco, anunciaram os resultados da nona Pesquisa sobre o Futuro do Código Aberto. Eles descobriram que as empresas estão adotando software open source em massa, mas não estão gerenciando esse software de forma satisfatória.

Lou Shipley, CEO da Black Duck, disse em uma declaração “Nos resultados desse ano, se tornou mais evidente que as empresas precisam de gerenciamento e governança do código aberto para alcançar seu uso completo. Isso é crítico para reduzir riscos legais, operacionais e de segurança em potencial, ao mesmo tempo em que permite às companhias colher todos os benefícios que o software de código aberto fornece”.

The Future of Open Source 2015

Algumas das informações obtidas com essa pesquisa podem ser sumarizadas como segue:

• 78% dos respondentes disseram que suas empresas executam parte ou todas as suas operações em software open source e 66% disseram que suas empresas criam softwares para seus clientes baseados em código aberto. Esta estatística mais que dobrou desde 2010, quando 42% dos respondentes à pesquisa disseram que usam open source para tocar seu negócio ou em seus ambientes de TI.
• 93% dissearm que o uso de open source por suas empresas aumentou ou permaneceu no mesmo patamar no ano passado
• 64% das empresas atualmente participam em projetos open source – em contraste com 50% em 2014. Para os próximos 2 ou 3 anos, espera-se que 88% das empresas aumentem suas contribuições para projetos de código aberto.
• Sotfwares open source tem se tornado a abordagem padrão para o software com ais de 66% dos respondentes dizendo que levam em consideração softwares open source antes de tentar outras opções.

Além disso, a pesquisa também revelou que:

• 55% acreditam que software de código aberto são mais seguros quando comparados com soluções de software proprietário.
• 58% pensam que o open-source são mais dimensionáveis e 43% disseram que o open source fornece uma facilidade de implantação superior à de softwares proprietários.
• Ao avaliar tecnologias de segurança para uso interno, 45% disseram que as opções open source são as primeiras a serem consideradas.

Olhando para o futuro, aqueles que responderam à pesquisa vêem Cloud computing (39%), big data (35%), sistemas operacionais (33%), e a Internet das Coisas – IoT (31%) sendo impactadas por software de de código aberto nos próximos 2 ou 3 anos.

Estes números parecem baixos apesar disso. Por exemplo, à exceção de produtos de nuvem da Microsoft e VMware, praticamente todo o resto em termos de cloud é software opensource. Na verdade, a Microsoft também aderiu ao software open source em usa nuvem Azure com o Docker e a VMware tem sua própria nuvem OpenStack. Provavelmente a nuvem rodará OSS.

Porém, antes de ficarmos muito animados proclamando que o software open source “venceu”  e o software proprietário irá morrer, devemos levar em conta que as empresas ainda não possuem políticas formais de gerenciamento de open source. A pesquisa também descobriu que:

• Mais de 55% dos respondentes disseram que suas empresas não possuem procedimentos ou políticas formais para o uso de software open source. Além disso, apenas 27% possuem uma política formal de contribuições dos funcionários a projetos OSS.
• Apenas 16% possuem um processo de aprovação de código automatizado e menos de 42% mantém um inventório de componentes open source.
• Mais de 50% não estão satisfeitos com sua habilidade em compreender as vulnerabilidades de segurança conhecidas em componentes open-source, e apenas 17% planejam monitorar código open source para descobrir vulnerabilidades de segurança.

Open Source Initiative

Tudo isso é preocupante, mas há um problema ainda maior: as empresas muitas vezes vêem o software open source como algo “mágico” que é totalmente livre de problemas de segurança. É esse tipo de crença cega que levou, por exemplo, à falha de segurança Heartbleed.

De qualquer forma, é excelente que o software de código aberto esteja se tornando um favorito nas empresas. As empresas parecem finalmente estarem vendo o valor do modelo de desenvolvimento de software open source. Mas isso deve ser feito com  cuidado e planejamento para evitar problemas e trazer soluções de forma satisfatória.

Para saber mais sobre open source, visite o site da Open Source Initiative.

Fonte:  ZDNet

O post 78% das empresas usam Software Open Source apareceu primeiro em Bóson Treinamentos em Ciência e Tecnologia.