T62. Llenguatges de programació

Desarrollo del tema

# LLENGUATGES DE PROGRAMACIÓ

## 1. Introducció

Un **llenguatge de programació** és un sistema formal de notació que permet escriure instruccions per a un ordinador. Actua com a intermediari entre el pensament humà i l'execució de la màquina. Des dels primers codis màquina fins als llenguatges moderns d'alt nivell, l'evolució ha estat marcada per la cerca d'abstracció, llegibilitat i expressivitat.

Per als matemàtics, els llenguatges de programació són eines fonamentals per implementar algorismes, realitzar càlculs simbòlics i numèrics, i explorar estructures matemàtiques.

## 2. Conceptes Fonamentals

### 2.1 Sintaxi i Semàntica

**Sintaxi:** Conjunt de regles que defineixen les combinacions vàlides de símbols. Es descriu formalment mitjançant gramàtiques (normalment BNF o EBNF).

**Semàntica:** Significat de les construccions sintàctiques. Hi ha tres enfocaments: - **Operacional:** Descriu l'execució pas a pas - **Denotacional:** Assigna significats matemàtics (funcions) - **Axiomàtica:** Basada en precondicions i postcondicions (lògica de Hoare)

### 2.2 Compiladors i Intèrprets

**Compilador:** Tradueix tot el programa a codi màquina abans d'executar-lo. Exemples: C, C++, Rust.

**Intèrpret:** Executa el programa línia a línia. Exemples: Python, JavaScript, Ruby.

**Híbrids:** Alguns llenguatges compilen a un codi intermedi (bytecode) que després s'interpreta. Exemples: Java (JVM), Python (.pyc).

### 2.3 Tipatge

**Tipatge estàtic:** Els tipus es comproven en temps de compilació. Exemple: Java, C. ```java int x = 5; // x sempre serà enter ```

**Tipatge dinàmic:** Els tipus es comproven en temps d'execució. Exemple: Python, JavaScript. ```python x = 5 # x és enter x = "hola" # ara x és string ```

**Tipatge fort:** No permet conversions implícites entre tipus incompatibles.

**Tipatge feble:** Permet conversions automàtiques.

## 3. Evolució Històrica

### 3.1 Primera Generació: Codi Màquina

Instruccions en binari directament executables pel processador. Específic per a cada arquitectura.

``` 10110000 01100001 ; MOV AL, 61h ```

### 3.2 Segona Generació: Llenguatge Assemblador

Mnemonics que representen instruccions màquina. Requereix un assemblador per traduir.

```assembly MOV AX, 5 ADD AX, 3 ```

### 3.3 Tercera Generació: Alt Nivell

**FORTRAN (1957):** Formula Translation. Primer llenguatge d'alt nivell, orientat a càlcul científic.

**COBOL (1959):** Business-oriented. Per aplicacions comercials.

**LISP (1958):** List Processing. Pioner en intel·ligència artificial i programació funcional.

**ALGOL (1960):** Influential en el disseny de llenguatges posteriors (estructura de blocs).

**BASIC (1964):** Beginner's All-purpose Symbolic Instruction Code. Per a ensenyament.

**C (1972):** Desenvolupat per Dennis Ritchie. Balanç entre alt nivell i control de maquinari.

### 3.4 Quarta Generació

Llenguatges més propers al problema que a la màquina: SQL, MATLAB, R.

### 3.5 Cinquena Generació

Llenguatges basats en restriccions i lògica: Prolog.

## 4. Paradigmes de Programació

### 4.1 Programació Imperativa

Descriu **com** fer les coses mitjançant seqüències d'instruccions que modifiquen l'estat.

**Característiques:** - Variables i assignacions - Estructures de control (if, while, for) - Procediments i funcions

**Exemple (C):** ```c int factorial(int n) { int result = 1; for (int i = 2; i <= n; i++) { result *= i; } return result; } ```

### 4.2 Programació Orientada a Objectes (POO)

Organitza el codi en **objectes** que encapsulen dades (atributs) i comportament (mètodes).

**Principis:** - **Encapsulació:** Ocultar detalls interns - **Herència:** Classes derivades hereten de classes base - **Polimorfisme:** Mateixa interfície, diferents implementacions - **Abstracció:** Modelar conceptes rellevants

**Exemple (Python):** ```python class Poligon: def __init__(self, costats): self.costats = costats def perimetre(self): return sum(self.costats)

class Triangle(Poligon): def area(self): # Fórmula de Heró a, b, c = self.costats s = self.perimetre() / 2 return (s*(s-a)*(s-b)*(s-c))**0.5 ```

### 4.3 Programació Funcional

Basat en l'avaluació de **funcions matemàtiques**. Evita estat mutable i efectes secundaris.

**Característiques:** - **Funcions pures:** Mateix input → mateix output, sense efectes laterals - **Immutabilitat:** Les dades no es modifiquen - **Funcions d'ordre superior:** Funcions que reben o retornen funcions - **Avaluació mandrosa (lazy):** Calcular només quan cal

**Exemple (Haskell):** ```haskell factorial :: Integer -> Integer factorial 0 = 1 factorial n = n * factorial (n - 1)

-- Amb fold factorial' n = foldr (*) 1 [1..n] ```

**Càlcul Lambda:** Base teòrica de la programació funcional. Definit per Alonzo Church (1936).

$$(\lambda x. x + 1) \, 5 = 6$$

### 4.4 Programació Lògica

Basat en la **lògica formal**. El programa és un conjunt de fets i regles; l'execució és una demostració.

**Exemple (Prolog):** ```prolog pare(joan, maria). pare(joan, pere). germà(X, Y) :- pare(Z, X), pare(Z, Y), X \= Y.

?- germà(maria, pere). true. ```

### 4.5 Programació Declarativa

Descriu **què** es vol obtenir, no com obtenir-ho.

**Exemple (SQL):** ```sql SELECT nom, nota FROM alumnes WHERE nota >= 5 ORDER BY nota DESC; ```

## 5. Estructures de Control

### 5.1 Seqüència

Execució ordenada d'instruccions.

### 5.2 Selecció (Condicional)

``` Si condició llavors instruccions_si_cert Sinó instruccions_si_fals Fi Si ```

**Múltiple:** ``` Segons expressió Cas valor1: instruccions1 Cas valor2: instruccions2 Altrament: instruccions_defecte Fi Segons ```

### 5.3 Iteració (Bucles)

**Mentre (while):** Repeteix mentre la condició sigui certa. ``` Mentre condició fer instruccions Fi Mentre ```

**Per (for):** Repeteix un nombre determinat de vegades. ``` Per i des de 1 fins a n fer instruccions Fi Per ```

**Repetir-fins (do-while):** Executa almenys una vegada.

### 5.4 Recursivitat

Una funció que es crida a si mateixa.

**Exemple:** Successió de Fibonacci $$F_n = F_{n-1} + F_{n-2}, \quad F_0 = 0, F_1 = 1$$

```python def fibonacci(n): if n <= 1: return n return fibonacci(n-1) + fibonacci(n-2) ```

## 6. Estructures de Dades

### 6.1 Tipus Primitius

- **Enters:** int, long - **Reals:** float, double - **Caràcters:** char - **Booleans:** true/false

### 6.2 Estructures Compostes

**Arrays/Vectors:** Col·lecció d'elements del mateix tipus amb accés per índex. $O(1)$ accés, $O(n)$ cerca.

**Llistes enllaçades:** Nodes amb dada i punter al següent. $O(1)$ inserció, $O(n)$ accés.

**Piles (Stack):** LIFO (Last In, First Out). Operacions: push, pop, top.

**Cues (Queue):** FIFO (First In, First Out). Operacions: enqueue, dequeue.

**Arbres:** Estructura jeràrquica. Arbres binaris de cerca: $O(\log n)$ operacions si equilibrat.

**Grafs:** Conjunt de vèrtexs i arestes. Representació: matriu d'adjacència o llistes d'adjacència.

**Taules hash:** Accés $O(1)$ mitjà mitjançant funció de dispersió.

## 7. Llenguatges per a Matemàtiques

### 7.1 Python

Llenguatge d'alt nivell, sintaxi clara, biblioteques potents: - **NumPy:** Càlcul numèric amb arrays - **SciPy:** Algorismes científics - **SymPy:** Càlcul simbòlic - **Matplotlib:** Visualització

```python from sympy import symbols, expand, factor x = symbols('x') expr = (x + 1)**3 print(expand(expr)) # x³ + 3x² + 3x + 1 ```

### 7.2 MATLAB/Octave

Especialitzat en càlcul matricial i visualització.

```matlab A = [1 2; 3 4]; B = inv(A); % Matriu inversa eig(A) % Valors propis ```

### 7.3 R

Orientat a estadística i visualització de dades.

### 7.4 Julia

Alt rendiment per a càlcul científic, sintaxi similar a MATLAB.

### 7.5 Wolfram Mathematica

Potent sistema de càlcul simbòlic.

### 7.6 GeoGebra

Programari de geometria dinàmica amb llenguatge d'scripting.

## 8. Programació en l'Ensenyament de Matemàtiques

### 8.1 Scratch

Programació visual amb blocs. Ideal per a primària i ESO inicial. - Conceptes: seqüència, bucles, condicionals - Projectes: simulacions geomètriques, jocs matemàtics

### 8.2 Python a l'Aula

**Avantatges:** - Sintaxi llegible - Gratuït i multiplataforma - Biblioteques matemàtiques

**Activitats:** - Generar taules de multiplicar - Calcular nombres primers - Graficar funcions - Simular probabilitat

### 8.3 Pensament Computacional

Habilitats transferibles: - **Descomposició:** Dividir problemes complexos - **Reconeixement de patrons:** Identificar regularitats - **Abstracció:** Ignorar detalls irrellevants - **Algorísmia:** Dissenyar solucions pas a pas

## 9. Aplicacions Didàctiques

### 9.1 ESO

- **Scratch:** Programar operacions amb fraccions - **GeoGebra:** Scripts per a construccions geomètriques - **Python bàsic:** Calcular MCD amb Euclides - **Projectes:** Xifrat Cèsar, generadors de nombres aleatoris

### 9.2 Batxillerat

- **Python avançat:** Mètodes numèrics (Newton-Raphson, integració) - **Recursivitat:** Fibonacci, Torres de Hanoi - **Grafs:** Dijkstra, recorreguts BFS/DFS - **Estadística:** Anàlisi de dades amb pandas

## 10. Conclusions

Els llenguatges de programació són eines essencials per al matemàtic modern. El paradigma funcional té arrels profundes en la matemàtica (càlcul lambda), mentre que la programació lògica es basa en la lògica formal. Dominar diferents paradigmes enriqueix la capacitat de resoldre problemes i permet triar l'eina adequada per a cada tasca. A l'aula, la programació desenvolupa el pensament computacional i fa les matemàtiques més tangibles i interactives.