Paradigimar

[pic 1]

FACULDADE ANHANGUERA DE ANÁPOLIS

CURSO: CIÊNCIA DA COMPUTAÇÃO

DISCIPLINA: PARADIGMAS DE LINGUAGEM DE PROGRAMAÇÃO

 

PROFESSOR: ROBERTO BITTAR

ALUNOS	RA
Miquéias Fernandes de Araújo	9930000441
Marcos Vinícius Guimarães Alves	1593858729
Gleyson Dias Cordeiro	1581976600
Daniel Faria Macedo	1569221128

RELATÓRIO 01: CRITÉRIOS DE AVALIAÇÃO DAS LINGUAGENS DE PROGRAMAÇÃO

Abril de 2015.

---

Introdução

Vamos falar sobre Linguagem de programação,LP vista pela sintaxe, é um grupo de regras onde explica a modo de uma linguagem

A semântica relatam o significado de construções sintáticas validas Legibilidade: se a linguagem tiver uma boa legibilidade,

fica de fácil entendimento o código a simplicidade global afeta fortemente a legibilidade de uma LP, pois um grande número de

componentes básicos Tipos de dados e Estruturas: as facilidades adequadas para definir os tipos de dados e estruturas em uma LP

é outro auxilio significativo para a legibilidade.

Defina o que é uma Linguagem de programação sob conotação Sintática e também Semântica.

Uma LP vista pela sintaxe, é um grupo de regras onde explica a modo de uma linguagem, escolhe como são agrupado as suas estruturas básicas (palavras).

A sintaxe de uma LP é constituída por regras sintáticas.

As regras lexias relatam as ligações válidas de caracteres que formam os tokens da LP, que são as palavras privado, identificadores, operadoras.

As regras sintáticas relatam como os tokens podem ser combinados para criar instruções validas.

A semântica relatam o significado de construções sintáticas validas. frequentemente uma LP é descrita informalmente, utilizando-se linguagem natural (Inglês, Português).
Semânticas formais são usadas principalmente para comprovar propriedades de LPs, construções semânticas e algoritmos. Existem também as semânticas, Operacionais, De notacional e Axiomática.

Semântica Operacional: tem como objetivo relatam como uma computação é processada. frequentemente faz o uso de uma maquina abstrata e de regras que relatam as mudanças de estado reunir a cada comando.

Semântica De notacional: relata um programa através de objetos matemáticos como conjuntos, funções, valores e as relações entre estes.

Semântica Axiomática: baseada em técnica de dedução lógica, relata uma linguagem através de axiomas usualmente é utilizada para comprovar propriedades de algoritmos.

Descreva o que influi e quais fatores que melhoram os seguintes critérios de avaliação de linguagem de programação: Legibilidade, Capacidade de Escrita e Confiabilidade.

Legibilidade: se a linguagem tiver uma boa legibilidade, fica de fácil entendimento o código, e assim o tornando de fácil manutenção, o desenvolvimento e a depuração dos programas ficam mais fáceis.

Temos alguns fatores importantes que melhora a legibilidade de uma LP:

- Simplicidade Global: a simplicidade global afeta fortemente a legibilidade de uma LP, pois um grande número de componentes básicos a deixa mais difícil de ser compreendida, do que uma com poucos componentes. Uma segunda característica que complica uma linguagem de programação é a multiplicidade de recurso, mais de uma maneira de realizar a mesma tarefa, assim se uma linguagem de programação tiver menos multiplicidade de recurso se torna mais fácil para o desenvolvimento do programador. 

Ortogonalidade: é um grupo relativo de pequenos construtores primitivos que podem ser combinados relativamente, assim possibilitando a construção de estrutura de controle de dados da LP. Alem disso toda combinação possível de primitivas é legal e significativa.

-Tipos de dados e Estruturas: as facilidades adequadas para definir os tipos de dados e estruturas em uma LP é outro auxilio significativo para a legibilidade. Pois podemos utilizar um sinalizador da linguagem ou mesmo criarmos um tipo de sinalizador se a LP não der suporte.

-Considerações sobre a Sintaxe: a sintaxe ou a forma dos elementos de uma LP, tem um efeito muito significativo sobre a legibilidade dos programas. Temos três exemplos de opções de projeto sintático que afetam a legibilidade:

Formas identificadoras, se usadas de maneira a exibir de tamanhos muito pequenos prejudicam a legibilidade. 

Palavras especiais são palavras reservadas pela linguagem e destacadas, onde elas executam uma determinada instrução.

Forma e significado projetam instruções, a fim de que sua aparência indique parcialmente sua finalidade, é um auxilio evidente para legibilidade.

Capacidade de escrita: o quanto é fácil utilizar uma linguagem para escrever um programa. Para obter uma capacidade de escrita em uma LP precisamos avaliar os critérios abaixo:

-Simplicidade e Ortogonalidade: se uma LP tiver um grande número de construções diferentes, alguns programadores podem não estar familiarizados com todas elas. Assim levando-os a usos inadequados de alguns recursos e ao desuso de outros que podem ser ou mais elegantes ou mais eficientes do que os usados. Isso pode levar o programador a chegar a resultados bizarros, sendo que se uma LP tiver um número menor de construções primitivas e um conjunto consistente de regras para combinar é muito melhor que, ter um número grande primitivas. Um programa complexo pode ser desenvolvido com um conjunto simples de construções primitivas.
Por outro lado a ortogonalidade pode causar prejuízo para a capacidade de escrita, com erros ao escrever programas podem não ser detectados, sendo que quase todas as combinações primitivas são legais, levando ao compilador não identificar os erros.

-Suporte para Abstração: é a capacidade de definir, e depois, usar estruturas de operações complicadas de uma maneira que permita ignorar muitos dos detalhes. O grau de abstração permitido por uma LP e a naturalidade de sua expressão são muito importante para sua capacidade de escrita, nas linguagens podemos ter dois tipos de abstração, o de processo e o de dados.

-Expressividade: em uma LP expressividade pode referir-se a diversas características diferentes, por exemplo, há muitos operadores poderosos permitindo que uma grande quantidade de computação seja realizada com um programa muito pequeno. Mas também significa que uma LP tem formas relativamente convenientes, em vez de desajeitadas, de se especificar. Com toda essa expressividade aumenta a capacidade de escrita de uma LP.

Confiabilidade: Um programa é considerado confiável quando segue todas suas especificações e suas condições. Abaixo podemos verificar as subseções que exercem um efeito significativo sobre a confiabilidade de uma LP.

-Verificação de tipo: é verificar se existem erros de tipo em determinado programa, ou pelo compilador ou durante a execução do programa. Verificação de tipos é muito importante na confiabilidade de uma LP. Quanto mais erros forem detectados com antecedência em um programa mais rápido serão corrigidos os erros.

-Manipulações de Exceções: programas com a capacidade de interceptar erros em tempo de execução, no caso colocar em prática medidas corretivas, e depois prosseguir é um grande auxílio para a confiabilidade. Essa facilidade da LP é chamada de Manipulação de Exceções.

-Apelidos: é ter dois ou mais métodos, ou nomes, distintos para fazer referencia a mesma célula da memória, é amplamente aceito que os apelidos são um recurso perigoso em uma LP, pois as LPs permitem algum tipo de apelido, isso pode causar confusões na leitura do programa ou ate mesmo em sua execução.

-Legibilidade e Capacidade de Escrita: sua legibilidade e capacidade escrita influenciam na confiabilidade, pois um programa escrito em uma linguagem que não suportam maneiras naturais de expressar os algoritmos exigidos usará necessariamente métodos não naturais, assim tornando-os com menos probabilidade de estarem corretos para todas as situações possíveis, se um programa for mais fácil de escrever é maior a probabilidade de ele estar correto. Sua legibilidade afeta sua confiabilidade tantos nas fases de escrita como nas de manutenção em seu ciclo.

-Custo: o custo final de uma LP depende de muito de suas características, pois temos de analisar seis critérios primeiramente:
O custo do treinamento de programadores para usar a LP, é uma função da simplicidade e ortogonalidade da LP, e da experiência doa programadores, muitas LPs poderosas não são difíceis de aprender.
O custo para escrever programas na LP, é uma função de sua capacidade de escrita, a qual depende de sua proximidade de propósito com a aplicação particular. Os esforços originais para projetar e implementar LP de alto nível foram motivados para diminuir os custos da criação de software. 
O custo para compilar programas na LP. Um grande empecilho é o custo proibitivamente elevado para rodar os compiladores de primeira geração, este problema foi diminuindo pelo surgimento de compiladores melhores.
Para executar programas o custo é grandemente influenciado pelo projeto da LP, se exigir muitas verificações de tipos durante a execução, isso fará com que a execução do código não seja rápida, independente da qualidade do compilador. Isso que a principal preocupação do projeto fosse a eficiência.
O custo do sistema de implementação da LP, se uma LP exige um sistema de implementação caro, ou rode em hardware caro, terá menos chance de tornar-se popular.
O custo da má confiabilidade, se o software tiver uma falha em um sistema crítico, isso tornaria o custo muito alto. As falhas de sistemas não críticos também podem ser muito caras em termo de futuro comercial ou de ações judiciais em função de sistemas de software defeituosos. Podemos considerar que o custo de manutenção dos programas, inclui tanto correções como modificações para adicionar novas capacidades.

3 Apresente um exemplo de trecho de código fácil e difícil de ler, indique de quais linguagens de programação eles se referem. Explique o porquê da diferença. 
Informix 4gl
#------------------------------#
FUNCTION svdp0131_incluir_multa()
#------------------------------#
#definição de variáveis 
DEFINE l_ind SMALLINT
DEFINE l_funcao CHAR(20)

#atribuindo valor falso para a variável
LET m_consulta_ativa = FALSE 
#limpa a tela
CLEAR FORM

#laço for para inicializar as variáveis de array nulas
FOR l_ind = 1 TO 999
INITIALIZE ma_multasr[l_ind].* TO NULL 
# faz um espelho dos dados apresentados em tela
LET ma_multasr[l_ind].* = ma_multas[l_ind].*
INITIALIZE ma_multas[l_ind].* TO NULL
END FOR 

#verifica a condição de entrada de dados na tela quando for uma Inclusão, e chama a função para verificação dos campos a serem imputados
IF svdp0131_entrada_dados_multa('INCLUSAO')THEN
#atribui valor verdadeiro para a variável
LET m_consulta_ativa = TRUE
#chama a função que faz inserção no banco de dados
CALL svdp0131_insert_multa()
ELSE
#atribui valor branco para a variável mensagem
MESSAGE " "
#for para inicialização de variáveis nulas e espelho, e limpa a tela
FOR l_ind = 1 TO 999
INITIALIZE ma_multas[l_ind].* TO NULL
LET ma_multasr[l_ind].* = ma_multas[l_ind].* 
CLEARFORM
#exibe dados da variável de array na tela
DISPLAY ARRAY ma_multasr TO sr_multas.*
END FOR 
END IF

END FUNCTION

# função de inserção de dados no banco de dados
#-----------------------------#
FUNCTION svdp0131_insert_multa()
#-----------------------------#
DEFINE l_ind SMALLINT
DEFINE l_seq INTEGER
DEFINE l_entrou SMALLINT
DEFINE sql_stmt CHAR(5000)
DEFINE l_hora CHAR(08)

#inicia uma transação para inserção no banco de dados 
CALL log085_transacao("BEGIN")

#Atribuiu a hora corrente na variável 
LET l_hora = TIME

#Busca a sequencia do registro através do numero do acordo
SELECT num_seq
INTO l_seq
FROM s_contrato_mestre
WHERE num_acordo = mr_acordo.num_acordo

# faz um laço verificando se a variável não esta nula inserindo no banco de dados, e gravando uma tabela de auditoria
FOR l_ind = 1 TO 999 
IF ma_multas[l_ind].descricao IS NOT NULL OR ma_multas[l_ind].descricao " " THEN
INSERT INTO s_contrato_multas VALUES (ma_multas[l_ind].descricao,
ma_multas[l_ind].multa_pec,
ma_multas[l_ind].multa_val,
l_ind,
l_seq)

INSERT INTO s_contrato_multas_audit VALUES(ma_multas[l_ind].descricao,
ma_multas[l_ind].multa_pec,
ma_multas[l_ind].multa_val,
l_ind,
l_seq,
p_user,
TODAY,
l_hora,
"I") 
END IF 
END FOR

#Verifica se se o retorno do insert não obteve nenhum erro
IF sqlca.sqlcode = 0 THEN
#encerra a transação inserindo os dados no banco
CALL log085_transacao("COMMIT")
#exibe mensagem que incluiu os dados com sucesso
MESSAGE "Inclusão efetuada com sucesso.”.
ELSE
#se por algum motive der erro na inclusão termina a transação e não grava os dados no banco
CALL log003_err_sql("INSERT","s_contrato_multas")
CALL log085_transacao("ROLLBACK")
LET m_consulta_ativa = FALSE
END IF

END FUNCTION

#função onde são verificados os campos a serem imputados
#---------------------------------------------#
FUNCTION svdp0131_entrada_dados_multa(l_funcao)
#---------------------------------------------#
DEFINE l_funcao CHAR(20) 

#comando que faz o cursor entrar nos campos de tela
INPUT ARRAY ma_multas.* WITHOUTDEFAULTS FROM sr_multas.*
ATTRIBUTES(INSERT ROW = FALSE, DELETE ROW = FALSE, MAXCOUNT = m_count)

#antes de carregar as linhas atribuem valores nas variáveis das linhas correntes
BEFORE ROW
LET m_ma_cur = ARR_CURR()
LET m_sc_cur = SCR_LINE()
LET m_count = ARR_COUNT()

#antes do campo descrição verifica se a variável m_inclui é verdadeira se for exibe em tela os dados que contem nas variáveis
BEFORE FIELD descricao
IF m_inclui = TRUE THEN
DISPLAY mr_acordo.num_acordo TO num_acordo2
DISPLAY mr_acordo.cod_cli_rede_cnpj TO cod_cli_rede_cnpj2
DISPLAY mr_acordo.den_cli_rede_cnpj TO den_cli_rede_cnpj2
END IF 

#apos o campo descricao se a variável não estiver nula, ira verificar se a variável mult_perc esta nula, se estiver ira atribuir o valor de zero e exibir os dados em tela 
AFTER FIELD multa_pec
IF ma_multas[m_ma_cur].descricao IS NOT NULL OR ma_multas[m_ma_cur].descricao " " THEN
IF ma_multas[m_ma_cur].multa_pec IS NULL OR ma_multas[m_ma_cur].multa_pec = " " THEN
LET ma_multas[m_ma_cur].multa_pec = 0
DISPLAY ma_multas[m_ma_cur].multa_pec TO sr_multas[m_sc_cur].multa_pec
END IF
END IF 

#apos o campo descricao se a variável não estiver nula, ira verificar se a variável mult_val esta nula, se estiver ira atribuir ovalor de zero e exibir os dados em tela 
AFTER FIELD multa_val
IF ma_multas[m_ma_cur].descricao IS NOT NULL OR ma_multas[m_ma_cur].descricao " " THEN
IF ma_multas[m_ma_cur].multa_val IS NULL OR ma_multas[m_ma_cur].multa_val = " " THEN
LET ma_multas[m_ma_cur].multa_val = 0
DISPLAY ma_multas[m_ma_cur].multa_val TO ma_multas[m_sc_cur].multa_val
END IF
END IF 

#se sair do input ele atribuirá verdadeiro para o Int_flag, e sairá do input 
AFTER INPUT
IF INT_FLAG = TRUE THEN 
EXIT INPUT 
END IF 

END INPUT

#se a int_flag for verdadeira exibira a mensagem de erro, ou se for falsa mensagem de dados inseridos com sucesso
IF INT_FLAG = TRUE THEN
LET INT_FLAG = 0 
ERROR "Processo cancelado pelo usuário."
RETURN FALSE
ELSE 
LET m_consulta_ativa = TRUE
MESSAGE "Dados informados com sucesso."
RETURN TRUE
END IF 

END FUNCTION

...