programacao estruturada II

Prévia do material em texto

13
Anhanguera Educacional
Unidade Santo André
Curso de Graduação em Sistemas de Informação
Matheus Carvalho
Ra:7087573663
Trabalho de programa de recuperação de aprendizagem
Programação estruturada II
Santo André
 2017
Matheus Carvalho
Ra:70875663
Trabalho de programa de recuperação de aprendizagem
Programação estruturada II
Trabalho de recuperação de aprendizagem . 
Orientador: Cleonice reis 
Santo André
2017
ERIC GRAVES CAMOLLEZ 7244587081
AGRADECIMENTOS
Agradeço a todos que me apoiaram durante toda a minha vida e também aos meus pais que me incentivaram e me apoiaram para que eu chegasse até aqui.
Agradeço também a Deus por ter me ajudado em todos os momentos para passar pelas dificuldades e desafios enfrentados.
Aos amigos que colaboraram de todas as formas para a realização das etapas do trabalho e também aos orientadores que nos direcionou da melhor forma possível.
RESUMO
Este trabalho inicialmente abordará conceitos técnicos de programação estruturada , abordara o conceito de programação estruturada , codificação em linguagem natural , codificação em fluxograma , funções em programação estruturadas e conceitos básicos em depuração e documentos de programas .
	
ABSTRACT
This work initially will address technical concepts considered fundamental about technology, theoretical and historical contexts intended to illustrate in figures formats, planned environment in its origins, and finally address the issues related to applications and key features of a business tool.
Data Warehouse is a database tool applied in large organizations and have a fundamental basis for the integration of data provide support for the extraction of reports and information related to decision-making, whether operational, and especially tactical or strategic, which in turn have a high degree of importance, the main system that integrates and controls the data is called Business Intelligence.
For the initial data can be generated and delivered to the customer, there is an OLAP tool called (Online Analytical Processing), which in turn has the function to make the collection, analysis, organization and sharing of all data relevant to the organization. This query is performed by the Data Warehouse data source.
Keywords: Data Warehouse; Pentaho; Business Intelligence (BI); Online Analytical Processing (OLAP).
 
Sumário
AGRADECIMENTOS	2
RESUMO	3
ABSTRACT	4
1-	Conceito de programação estruturada	6
2-	Depuração	6
2.1- Origem	6
2.2- Ferramentas	7
2.3- Processos	7
3-	Documentação de programas	8
4-	Processamento de linguagen natural	10
4.1 - Historia	10
4.2- Aprendizagem de maquina	11
5-	Codificação Fluxograma	12
6-	Funções em programação estruturada	13
REFERÊNCIAS	13
 
1- Conceito de programação estruturada
Programação estruturada é um paradigma de programação, forma de programação de computadores que preconiza que todos os programas possíveis podem ser reduzidos a apenas três estruturas: sequência, decisão ou seleção e iteração (esta última também é chamada de repetição), desenvolvida por Michael A. Jackson no livro "Principles of Program Design" de 1975.
Emergiu no final dos anos 1950 com as linguagens de programação ALGOL 58 e ALGOL 60.
Tendo, na prática, sido transformada na programação modular, a programação estruturada orienta os programadores para a criação de estruturas simples nos programas, usando as sub-rotinas e as funções. Foi a forma dominante na criação de software anterior à programação orientada por objetos.
Apesar de ter sido sucedida pela programação orientada por objetos, pode-se dizer que a programação estruturada ainda é muito influente, uma vez que grande parte das pessoas ainda aprendem programação através dela. Para a resolução de problemas relativamente mais simples e diretos, a programação estruturada é muito eficiente. Além disso, por exigir formas de pensar relativamente complexas, a programação orientada a objetos até hoje ainda não é bem compreendida ou usada pela maioria.
Há de acrescentar também que inúmeras linguagens ainda extremamente relevantes nos dias de hoje, como Cobol, PHP, Perl e Go ainda utilizam o paradigma estruturado (muito embora possuam suporte para a orientação a objeto).
2- Depuração
Depuração (em inglês: debugging, debug) é o processo de encontrar e reduzir defeitos num aplicativo de software ou mesmo em hardware. Erros de software incluem aqueles que previnem o programa de ser executado e aqueles que produzem um resultado inesperado.
2.1- Origem
Existe alguma controvérsia em relação a quem usou pela primeira vez o termo bug -- mas é possível que seu uso tenha se dado anteriormente ao famoso uso feito por Grace Hopper, notável desenvolvedora da Marinha dos Estados Unidos da América.
Quanto ao termo debug, aceita-se em geral que foi usado pela primeira vez por Glenford J Myers no seu livro, Software Reliability: Principles and Practices, em 1976.
2.2- Ferramentas
De forma geral, a depuração é uma tarefa difícil e trabalhosa, e a dificuldade varia de acordo com o ambiente de desenvolvimento, o que inclui a linguagem de programação e as ferramentas disponíveis, como depuradores. Depuradores são ferramentas que permitem ao programador monitorar a execução de um programa, pará-lo e reiniciá-lo, ativar pontos de parada, alterar áreas de memória e, em alguns casos, voltar no tempo.
De forma geral, linguagens de alto nível tornam a depuração mais fácil, pois fornecem mais ferramentas para identificar erros, como o tratamento de exceções. Em linguagens de baixo nível, erros de código podem causar problemas difíceis de serem identificados, como corrupção de memória. Nesse caso, depuradores de memória podem ser necessários.
Para certos tipos de problema existem ferramentas de análise do código fonte, que buscam por erros específicos no código, o que depende da linguagem de programação em uso. Enquanto um compilador se preocupa com a sintaxe do código fonte, tais ferramentas de análise focam a semântica. Um problema geralmente identificável através do código fonte é o uso duma variável antes da primeira atribuição.
Para a depuração de hardware, assim como software de baixo nível (como BIOS, firmware e drivers de dispositivo) instrumentos como osciloscópios, analisadores lógicos e emuladores são frequentemente usados.
2.3- Processos
A depuração começa com a tentativa de reprodução do problema, o que pode não ser uma tarefa simples, como em computação paralela. Após a reprodução, o problema deve ser reduzido até sua essência, para facilitar a depuração. É um processo iterativo em que para cada redução, uma nova execução é feita para assegurar a reprodução do problema. Como analogia, pode-se considerar esse processo de redução como uma forma de divisão e conquista. Para automatizar a redução da entrada, métodos de depuração delta podem ser usados. A redução pode ser feita com a simplificação das entradas do programa. Por exemplo, um programa que falha na leitura de milhares registros pode ter o problema associado a somente um deles, somente um registro possui valores que fazem o problema se manifestar; pode-se reduzir a quantidade de registros lidos até que reste somente um, o causador do problema. No caso de erro de software, a redução é chamada de isolamento de código. Após a identificação dum problema em certo código, pode-se percorrer o código fonte para isolar a origem do problema, a partir de módulos, passando por subrotinas e chegando na linha exata.
Após a reprodução do problema estar suficientemente reduzida (isolada), deve-se identificar o problema, num processo de dedução e teste da origem do problema. Para isso, o programador pode usar um depurador para examinar e alterar os estados do programa (valores de variáveis, pilha de chamada). Alternativamente, pode-se realizar um trace, um método de registro da execução de um programa. Em um caso simples, um trace registra os valores de variáveis em certospontos de execução do programa. Entretanto, assim como o processo de redução de entrada antes da depuração, deve-se realizar um processo de redução de variáveis registradas antes do trace, a fim de reduzir a quantidade de informação gerada, tornando o processo mais objetivo. A depuração remota é o processo de depuração de um programa sendo executado em um sistema diferente do depurador, numa conexão feita geralmente através duma rede.
3- Documentação de programas 
Como toda obra bem planejada, o código fonte de um programa desenvolvido deve conter regras para que as futuras customizações possam ser realizadas sem colocar em risco o tempo de implementação. Os pontos a serem atacados são:
 
·       Padronização no nome do programa a ser desenvolvido
·       Documentação inicial do programa
·       Documentação das principais variáveis utilizadas
·       Padronização do nome das variáveis e parâmetros
·       Documentação de pontos importantes no decorrer do código
 
As principais metodologias de programação existentes atualmente indicam que cerca de 50% do código fonte deve estar documentado. É iminente que esse tipo de preocupação está relacionada ao entendimento do programa desenvolvido por toda a equipe, fazendo com que o conhecimento não fique centralizado apenas no autor do código.
 
No exemplo abaixo temos um programa fonte escrito em linguagem Oracle PL/SQL escrito com metodologia de programação.Nesse exemplo, a cada execução de um programa no banco de dados, o seu respectivo nome e a data/hora de execução são armazenados em uma tabela de log, o mesmo acontecendo no término de sua execução. Sendo assim, tem-se o tempo total de execução do programa. Isso é muito útil para saber o a quantidade de vezes e o tempo médio de execução de cada programa. Veja como esse programa está bem documentado.
 
create or replace procedure prc_inicio
(
p_num_seq_log    out number,
p_nom_processo   in varchar2
) is
begin
--------------------------------------------------------
-- Objetivo    : A cada programa a ser executado, a data
--                  de início é registrada junto com o nome
--                  do programa. Quando o processo finalizar,
--                  a procedure prc_fim entra em ação para
--                  armazenar a data de término
-- Autor        : Gustavo Padlipskas
-- Criado em : 01/10/2005
-- Parâmetros: p_num_seq_log -> É o número do log gerado
--                                         para indicar que o pro-
--                                         grama está executando.
--                                         Esse é um parâmetro de
--                                         retorno (saída)
--                                                                                                    
--                  p_nom_processo-> É o nome do processo que
--                                         está sendo executado. Esse
--                                         parâmetro é de entrada e
--                                         deve ser passado pelo
--                                            programador 
-- Ultima Alteracao     Analista                  Descricao
-------------------------------------------------------------------
--  10/06/2006                Yuri Bello   Implementacao do controle
--     de exceção do programa                                                                                                           
-------------------------------------------------------------------
-- 1o. passo -> gerar um número novo indicando o início de execução
select administrador.spmgaz_seq.nextval into p_num_seq_log from dual;
 
begin
 insert into administrador.spmgaz_log(num_seq_log, nom_processo, nom_usuario, dat_inicio )
 values ( p_num_seq_log , p_nom_processo, user, sysdate );
   commit;
exception   -- 10/06/2006 - Implementado um controle de exceção para
            -- tratamento de erro - (Yuri Bello)
  when others then
    raise_application_error( -20001, 'Erro Crítico * Insert log ' || SqlErrM);
end;
end prc_inicio;
 
No exemplo acima, o programador Gustavo Padlipskas escreveu um código padrão, utilizando:
(escritas em minúsculas, entrada de parâmetros iniciando-se com a letra "p", comentário no programa inteiro, etc). Quando existir a necessidade de se realizar a manutenção do programa, facilmente qualquer profissional que conheça a ferramenta terá facilidade em realizar novas customizações. Imagine todos os programas feitos na empresa utilizando padrões na programação. A facilidade no entendimento das variáveis seria enorme.
 
Atualmente, um dos principais custos na área de TI (senão o maior) está relacionado à equipe de desenvolvimento de software. Evitar a documentação de um programa fonte faz com que esse custo aumente, pois caso o membro da equipe responsável em fazer as customizações não tenha sido o autor original do programa, faz com que o tempo final da customização aumente consideravelmente.
 
Por fim, para que você seja sempre bem recomendado no mercado de trabalho pelos seus colegas de trabalho, documente muito bem seus programas e utilize um padrão, por mais simples irá agregar valor nas próximas manutenções. Ele é o seu cartão de visita permanente e conta um pouco de sua história pelas empresas as quais você passou.
4- Processamento de linguagen natural
Processamento de linguagem natural (PLN) é uma subárea da ciência da computação, inteligência artificial e da linguística que estuda os problemas da geração e compreensão automática de línguas humanas naturais. Sistemas de geração de linguagem natural convertem informação de bancos de dados de computadores em linguagem compreensível ao ser humano e sistemas de compreensão de linguagem natural convertem ocorrências de linguagem humana em representações mais formais, mais facilmente manipuláveis por programas de computador. Alguns desafios do PLN são compreensão de linguagem natural, fazer com que computadores extraiam sentido de linguagem humana ou natural e geração de linguagem natural.
4.1 - Historia
A história do PLN começou na década de 1950, quando Alan Turing publicou o artigo "Computing Machinery and Intelligence", que propunha o que agora é chamado de teste de Turing como critério de inteligência.
Em 1954, a experiência de Georgetown envolveu a tradução automática de mais de sessenta frases russas para o inglês. Os autores alegaram que dentro de três ou cinco anos a tradução automática se trataria de um problema resolvido. No entanto, os avanços reais foram muito mais lentos do que o previsto e, após o relatório ALPAC em 1966, que constatou que a pesquisa de dez anos não conseguiu satisfazer as expectativas, o financiamento para este estudo em tradução automática foi reduzido drasticamente. Poucas pesquisas em tradução automática foram conduzidas até o final dos anos 80, quando os primeiros sistemas estatísticos de tradução foram desenvolvidos.
Alguns sistemas de PLN bem sucedidos desenvolvidos nos anos 60 foram SHRDLU, um sistema de linguagem natural que trabalhava em "blocks worlds" com vocabulário restrito e ELIZA, uma simulação de um psicoterapeuta escrita por Joseph Weizenbaum entre 1964 e 1966. Usando pouca informação sobre o pensamento ou a emoção humana, ELIZA criava, em alguns casos, interações surpreendentemente humanas. Quando o "paciente" excedia a base de conhecimento do programa, ELIZA fornecia uma resposta genérica, por exemplo, respondendo a "Minha cabeça dói" com "Por que você diz que sua cabeça dói?".
Durante a década de 1970, muitos programadores começaram a escrever "ontologias conceituais", que estruturaram a informação do mundo real em dados compreensíveis por computadores. Exemplos são MARGIE (SCHANK, 1975), SAM (CULLINGFORD, 1978), PAM (WILENSKY, 1978), TaleSpin (MEEHAN, 1976), QUALM (LEHNERT, 1977), Politics (CARBONELL, 1979) e Plot Units (LEHNERT, 1981 ). Neste período, muitos chatterbots foram escritos, como PARRY, Racter e Jabberwacky.
Até a década de 1980, a maioria dos sistemas de PLN se baseava em conjuntos complexos de regras manuscritas.A partir do final dos anos 1980, no entanto, houve uma revolução no PLN com a introdução de algoritmos de aprendizagem automática (aprendizado de máquina) para o processamento de linguagem. Isto foi devido tanto ao aumento constante do poder computacional (ver Lei de Moore) quanto à diminuição gradual da dominância das teorias da linguística chomskyanas (como a gramática gerativa), cujos fundamentos teóricos desestimularam o tipo de corpus linguístico que está subjacente à abordagem da aprendizagem automática ao processamento da linguagem.
Alguns dos algoritmos de aprendizado de máquinas mais antigos, como as árvores de decisão, produziam sistemas de regras rígidas então semelhantes às regras existentes na escritas à mão. No entanto, a marcação de partes da fala (part-of-speech tagging) introduziu o uso de modelos ocultos de Markov para o PLN e, cada vez mais, a pesquisa se concentrava em modelos estatísticos, que tomam decisões suaves e probabilísticas baseadas na atribuição de pesos reais aos recursos que compõem dados de entrada. Os modelos de linguagem de cache, sobre os quais muitos sistemas de reconhecimento de fala agora dependem, são exemplos de tais modelos estatísticos. Esses modelos são geralmente mais robustos quando dados informações desconhecidas, especialmente entrada que contém erros (como é muito comum para dados do mundo real) e produzem resultados mais confiáveis quando integrados em sistemas maiores que compreendem múltiplas tarefas.
Muitos dos sucessos iniciais notáveis ocorreram no campo da tradução automática, devido especialmente ao trabalho de pesquisa da IBM, que desenvolveu modelos estatísticos mais elaborados. Estes sistemas foram capazes de tirar proveito de corpora textuais multilíngues existentes produzidos pelo Parlamento do Canadá e a União Europeia como resultado de leis que exigem a tradução de todos os processos governamentais em todas as línguas oficiais dos países. No entanto, a maioria dos sistemas dependia de corpora desenvolvido especificamente para tarefas implementadas por esses sistemas, o que era (e muitas vezes continua sendo) uma grande limitação no sucesso dos mesmo. Como resultado, uma grande quantidade de pesquisa passou de quantidades de dados limitadas a métodos de aprendizagem mais eficazes.
Pesquisas recentes têm se concentrado cada vez mais em algoritmos de aprendizagem semi-supervisionados e sem supervisão. Esses algoritmos são capazes de aprender com dados que não foram anotados manualmente com as respostas desejadas ou usando uma combinação de dados anotados e não anotados. Geralmente, esta tarefa é muito mais trabalhosa do que a aprendizagem supervisionada e normalmente produz resultados menos precisos para uma quantidade específica de dados de entrada. No entanto, há uma enorme quantidade de dados não anotados disponíveis (incluindo, entre outras coisas, todo o conteúdo da World Wide Web), que muitas vezes pode compensar os resultados inferiores.
4.2- Aprendizagem de maquina
Os algoritmos modernos de PLN baseiam-se na aprendizagem mecânica, especialmente na aprendizagem de máquinas estatísticas. O paradigma da aprendizagem mecânica é diferente do da maioria das tentativas anteriores de processamento da linguagem. Anteriormente, implementações de tarefas de processamento de linguagem envolviam a codificação direta de grandes conjuntos de regras. O paradigma da aprendizagem automática (ou aprendizagem automática) induz a aprendizagem automática de regras através de análises de corpora de exemplos típicos do mundo real ao invés de usar algoritmos gerais de aprendizagem (muitas vezes, embora nem sempre, baseados em inferência estatística). Um corpus (plural "corpora") é um conjunto de documentos (ou frases individuais) que foram anotados à mão com os valores corretos a serem aprendidos.
Muitas classes diferentes de algoritmos de aprendizado de máquina foram aplicadas a tarefas de PLN. Esses algoritmos tomam como entrada um grande conjunto de "recursos" que são gerados a partir de dados de entrada.
Alguns dos algoritmos mais usados, como árvores de decisão, produziam sistemas de regras rígidas semelhantes aos sistemas de regras manuscritas mais comuns. No entanto, cada vez mais, a pesquisa tem se concentrado em modelos estatísticos, que tomam decisões flexíveis e probabilísticas baseadas em agregar pesos reais a cada característica de entrada. Tais modelos têm a vantagem de poder expressar a certeza relativa de muitas respostas possíveis diferentes em vez de apenas uma, produzindo resultados mais confiáveis quando esse modelo é incluído como um componente de um sistema maior.
Os sistemas baseados em algoritmos de aprendizagem mecânica têm muitas vantagens em relação às regras produzidas manualmente:
Os procedimentos de aprendizagem usados durante a aprendizagem da máquina focam-se automaticamente nos casos mais comuns, ao passo que quando se escrevem regras à mão, não é óbvio em que sentido o esforço deve ser dirigido.
Os procedimentos de aprendizagem automática podem fazer uso de algoritmos de inferência estatística para produzir modelos que são robustos a entradas não familiares (por exemplo, contendo palavras ou estruturas que não foram vistas antes) e a entradas errôneas (por exemplo, com palavras ou palavras incorretamente omitidas). Geralmente, lidar com essas entradas de forma com regras manuscritas ou sistemas de regras manuscritas que tomam decisões suaves é extremamente trabalhoso, propenso a erros e demorado.
Sistemas baseados em aprender automaticamente as regras podem ser mais precisos simplesmente fornecendo mais dados de entrada. No entanto, os sistemas baseados em regras escritas à mão só podem ser tornados mais precisos aumentando a complexidade das regras, o que é uma tarefa muito mais difícil. Em particular, há um limite para a complexidade de sistemas baseados em regras artesanais, para além dos quais os sistemas se tornam cada vez mais incontroláveis. No entanto, a criação de mais dados para entrada em sistemas de aprendizado de máquina requer simplesmente um aumento correspondente no número de horas trabalhadas por humanos, geralmente sem aumentos significativos na complexidade do processo de anotação.
O subcampo de PLN dedicado a abordagens de aprendizagem é conhecido como aprendizagem de linguagem natural (NLL) e sua conferência, a CoNLL, e orgão central, o SIGNLL, são patrocinados pela ACL, reconhecendo também as suas ligações com linguística computacional e aquisição de linguagem. Quando o objetivo da pesquisa de aprendizagem de linguagem computacional é entender mais sobre aquisição de linguagem humana, ou psicolinguística, a NLL sobrepõe-se no campo relacionado de psicolinguística computacional.
5- Codificação Fluxograma
Fluxograma é um tipo de diagrama, e pode ser entendido como uma representação esquemática de um processo ou algoritmo, muitas vezes feito através de gráficos que ilustram de forma descomplicada a transição de informações entre os elementos que o compõem, ou seja, é a sequência operacional do desenvolvimento de um processo, o qual caracteriza: o trabalho que está sendo realizado, o tempo necessário para sua realização, a distância percorrida pelos documentos, quem está realizando o trabalho e como ele flui entre os participantes deste processo.
Os fluxogramas são muito utilizados em projetos de software para representar a lógica interna dos programas, mas podem também ser usados para desenhar processos de negócio e o workflow que envolve diversos atores corporativos no exercício de suas atribuições. 
O Diagrama de fluxo de dados (DFD) utiliza do Fluxograma para modelagem e documentação de sistemas computacionais.
O termo Fluxograma designa uma representação gráfica de um determinado processo ou fluxo de trabalho, efetuado geralmente com recurso a figuras geométricas normalizadas e as setas unindo essas figuras geométricas. Através desta representação gráfica é possível compreender de forma rápida e fácil a transição de informações ou documentos entre os elementos que participam no processo emcausa.
O fluxograma pode ser definido também como o gráfico em que se representa o percurso ou caminho percorrido por certo elemento (por exemplo, um determinado documento), através dos vários departamentos da organização, bem como o tratamento que cada um vai lhe dando.
A existência de fluxogramas para cada um dos processos é fundamental para a simplificação e racionalização do trabalho, permitindo a compreensão e posterior otimização dos processos desenvolvidos em cada departamento ou área da organização.
6- Funções em programação estruturada
Funções
As funções são encapsulamentos de códigos a fim de deixar o programa mais prático, mais legível e dividi-lo em partes.
A vantagem da função é que se for preciso alterar alguma coisa no código será alterado somente uma vez no escopo da função e toda vez que for chamada aquela parte do código ela já será carregada com as novas configurações.
As funções são constituídas primeiramente por um tipo (int, float, dooble, char, ou um tipo definido) logo em seguida por um nome (que é dado pelo programador) e seguido de abre parênteses ‘(‘ se tiver parâmetros (parâmetros são como portas, os dados que você quer que a função receba da função principal, a função main() ).
Se eu quiser receber dois números inteiros da função main eu teria uma função do tipo:
void exemplo(int x, int b)
{
int resultado;
resultado = x + b;
}
As funções são como se pegasse uma parte de código responsável por fazer algum tipo de operação ou qualquer outro processo e a colocasse entre as sintaxes necessárias para se criar uma função, evitando assim de toda vez que precisarmos realizar alguma operação de ter que reescrever todo o código novamente.
Toda função precisa retornar um valor, exceto as do tipo void (funções do tipo void retornam sim um valor mas ele pode ser considerado desprezível nessas circunstâncias) o retorno é feito da seguinte forma:
return valor numérico;
ex: return 1;
Então, a nossa função exemplo() ficaria da seguinte forma se escrevêssemos ela do tipo int:
int exemplo(int x, int b)
{
int resultado;
resultado = x+b;
return resultado;
}
Parâmetros de Funções
Como foi dito logo no início, sobre variáveis. Existe dois modos de variáveis, as globais(que são reconhecidas em todo programa) e as locais(que são reconhecidas apenas dentro da função do qual ela foi declarada, após o termino da execução da função, ela é destruída).
Até o presente momento, não tem como acessar variáveis ou valores contidos em outras funções, para resolver este problema é serve os parâmetros de funções.
Por exemplo, eu tenho um programinha que possui duas funções mas uma função principal onde está rolando o programa, e uma função que é responsável por somar dois números, para mim passar esses dois números para a função soma eu preciso dos parâmetros.
Ex:
int soma(int num, int num1);
main()
{
int x, y, resultado;
cout << “\n\n Digite um numero:      ”;
cin >> x;
cout << “\n\n Digite um numero:      ”;
cin >>y;
resultado = soma(x,y);
cout << “\n\n O resultado é:     ” << resultado;
}
int soma(int num, int num1)
{
int resultado;
resultado = num + num1;
return resultado;
}
Depois do nome soma, o nome da função, entre os parênteses é que estão a declaração de parâmetros, ou seja, as “portas” de comunicação entre a função soma e a função principal, a função main(), portanto, sempre que eu quiser passar uma  quantidade X de números de uma função para outra, esse numero X de parâmetros é que devo ter na minha outra função.
Nesse caso, eu precisaria de passar dois valores inteiros para a minha função soma, por isso declarei dois parâmetros do tipo inteiro para mina função som.
	
REFERÊNCIAS