• Primer año: 9 meses de clase (septiembre - junio) con 30 horas semanales (6 horas/día de lunes a viernes)
• Segundo año: 6 meses de clase (septiembre - febrero) con 30 horas semanales también + 3 meses de prácticas en una empresa (marzo - mayo)

• Programación: El módulo principal de este año (8/30 horas semanales). Se suele hacer con Java (hasta donde yo sé). Si no tienes conocimientos previos en programación este es el módulo más difícil pero si ya sabes algo te resultará muy fácil, sobre todo los primeros meses, porque se empieza desde lo más básico. Aquí empiezas con los tipos de datos, operadores lógicos, estructuras de control y luego pasas a una parte un poco más avanzada con estructuras de datos, POO (herencia, polimorfismo,...) y acabas con algo de interfaces gráficas (swing).
• Bases de datos: 6/30 horas semanales. Aquí empiezas con diagramas entidad-relación y después de unos meses empiezas a utilizar bases de datos SQL. Al igual que en Programación, si no conoces nada de esto tendrás que esforzarte para no perderte pero si ya lo conoces, te será sencillo pues empieza de 0.
• Sistemas informáticos: 6/30 horas semanales. Esto es una mezcla con un poco de todo. Al principio tienes un poco de hardware: conocer los componentes de un ordenador (a grandes rasgos), después una parte de sistemas operativos (aquí verás funciones de configuración de Windows y Linux y algunos comandos de cmd/terminal). Yo diría que esta es la parte más complicada de este módulo pero también la más útil. Y finalmente algo de redes, direccionamiento IP y poco más.
• Lenguaje de marcas: 4/30 horas semanales. Empiezas con HTML y después empiezas a usar también algo de CSS. Esta parte no tiene mayor relevancia si no tiras hacia la programación web. Después tienes XML, esquemas de documento, XPath, XQuery. Está bien aunque puede que no llegues a usarlo después, XML sí.
• Entornos de desarrollo: 3/30 horas semanales. Aquí estudias un poco el IDE (en mi caso Eclipse) y las funciones que tiene para ayudarte a programar (refactorización, depuración,...). Después realización de tests (JUnit) y finalmente ves algo de diagramas (de clases, de comportamiento, casos de uso,...). Esta es un poco más teórica que las anteriores aunque digamos que complementa a la de programación entonces van un poco de la mano. Lo que aprendas aquí te servirá de ayuda para programación.
• Formación y orientación laboral: 3/30 horas semanales. Es el más teórico pero si estás empezando en el mundo laboral no está mal. Aprendes un poco cómo se regula el trabajo, a entender una nómina, los tipos de contrato que hay... y la parte final va sobre prevención de riesgos laborales. Si ya tienes experiencia con esto, no aprenderás prácticamente nada. Al finalizar este módulo obtienes un certificado en prevención de riesgos laborales. Este módulo además es común a todos los grados de formación profesional por lo que si tienes hecho otro de antes lo puedes convalidar y librarte de estas horas.

• Acceso a datos: 6/30 horas semanales. Aprenderás persistencia de datos. Crearás programas que utilicen ficheros de texto, bases de datos y al final verás ORM. Seguramente sea con Java también e Hibernate. Muy importante pues la gran mayoría de programas trabajan con datos que están almacenados en el sistema o en otras ubicaciones. No es muy complicado si has llevado bien Programación y Bases de datos en 1º.
• Programación de servicios y procesos:: 3/30 horas semanales. Que no te engañen esas 3 horas pues no serán fáciles. Aunque tengas experiencia programando es difícil acostumbrarse a la programación concurrente y a la sincronización correcta de hilos. Verás procesos e hilos, como conectarse unos con otros (pipes y sockets) y cómo mantener la consistencia utilizando la sincronización. Yo empecé las primeras prácticas en C (en Linux) y luego ya pasamos a Java. Seguramente será la asignatura que más tiempo tengas que dedicar pues son temas complejos y que no se ven hasta llegados a este punto.
• Desarrollo de interfaces: 6/30 horas semanales. Aquí profundizarás en las interfaces gráficas. Lo mejor que te puede pasar desde mi punto de vista es dar esta asignatura en C#. Así aprenderás otro lenguaje aplicando lo que sabes de Java a C# y verás WinForm y WPF muy fáciles de utilizar y muy demandados actualmente para crear GUIs. Además a partir de aquí podrás profundizar en .NET que es muy completo, potente y demandado. También puede que veas cómo generar informes (pdf) desde el programa, cosa que también se utiliza mucho a nivel empresarial.
• Programación multimedia y dispositivos móviles: 6/30 horas semanales. Aquí verás programación móvil (lo más seguro es que sea en Android mediante Java). Te servirá para conocer las bases pero si quieres dedicarte a ello tendrás que aprender mucho por tu cuenta pues nadie utiliza Java ahora para programación móvil. Aquí te servirá también el XML de 1º.
• Sistemas de gestión empresarial: 6/30 horas semanales. Aquí verás ERPs y CRMs. Dependiendo del profesor harás las prácticas con SAP (el ERP más conocido pero para el que hay que estar certificado por SAP para poder impartirlo) o con otros (a mí me tocó uno gratuito llamado Odoo). Este módulo tiene bastante teoría y puede llegar a ser aburrido pero dependerá también de la forma en que te lo impartan. Si tienes suerte aprenderás algo de Python a nivel básico.
• Empresa e Iniciativa emprendedora: 3/30 horas semanales. La continuación de Formación y Orientación Laboral. Aquí verás los tipos de sociedades que existen y características sobre todo. Puede que te toque hacer un proyecto de una startup durante todo el curso y no tendrás exámenes ni nada. En ese caso se agradece pues no tendrás que memorizar toda la teoría y si te interesa montar una startup puedes aprovechar ese proyecto para presentarlo a la hora de conseguir financiación. Al igual que FOL, es común y si tienes otro grado podrás convalidarlo y ganar tiempo para invertir en las primeras de la lista.

public class Dispositivo {
  private static SerialPort puertoSerie;
 
  public static void AbrirConexion(string nombreCOM) {...}
 
  public int Id { get; }
  public int NumeroSerie { get => ObtenerNumeroSerie(); }
  //...
} 

lock(puertoSerie) {
  EnviarComando(comando);
  respuesta = RecibirRespuesta();
}
// gestion de la respuesta 

public class Dispositivo {
  //...
  private static readonly Dictionary<int, Dictionary<string, string>> gestorRespuestas = new Dictionary<int, Dictionary<string, string>>();
  //...
} 

• Crear un array auxiliar y guardar después de cada iteración, la nota media (índice acumulado) de ese cuatrimestre. Al terminar haces la media de todos los valores del array y ya tienes la media de todos los cuatrimestres.
• Modificar la estructura Estudiante para poder almacenar todos los datos sin tener que sustituirlos en cada iteración.

#define MAX_CUATRIMESTRES 4
#define MAX_MATERIAS_CUATRIMESTRE 10
 
typedef struct {
    // los campos que consideres (nombre, edad, ...)
    int num_cuatrimestres;
    int materias[MAX_CUATRIMESTRES]; // El indice i indicara el numero de materias cursadas en el cuatrimestre i
    float notas[MAX_CUATRIMESTRES][MAX_MATERIAS_CUATRIMESTRE]; // El campo (i, j) indicara la nota de la materia j durante el cuatrimestre i
} Estudiante; 

#define MAX_ESTUDIANTES 50
 
int main() {
  Estudiante estudiantes[MAX_ESTUDIANTES];
 
  int num_estudiantes;
  // Para asegurarte de que se introduce un numero valido puedes hacer un filtro:
  // Utiliza los filtros para el resto de valores que tiene que introducir el usuario para asegurarte de que introducen valores validos
  do {
    printf("Introduce el numero de estudiantes: ");
    scanf("%d", &num_estudiantes);
  } while(num_estudiantes < 1 || num_estudiantes > MAX_ESTUDIANTES);
 
  for(int i = 0; i < num_estudiantes; ++i) {
    printf("Introduce el numero de cuatrimestres del estudiante %d: ", i+1);
    scanf("%d", &estudiantes[i].num_cuatrimestres);
 
    for(int j = 0; j < estudiantes[i].num_cuatrimestres; ++j) {
      printf("Introduce el numero de materias del estudiante %d durante el cuatrimestre %d: ", i+1, j+1);
      scanf("%d", &estudiantes[i].materias[j]);
 
      for(int k = 0; k < estudiante[i].materias[j]; ++k) {
        printf("Introduce la nota de la materia %d del cuatrimestre %d del estudiante %d: ", k+1, j+1, i+1);
        scanf("%f", &estudiantes[i].notas[j][k]);
      }
    }
  }
} 

float calcularMediaCuatrimestre(Estudiante estudiante, int cuatrimestre) {
  // tu codigo aqui
} 

float calcularMediaCompleta(Estudiante estudiante) {
  float sumaNotasCuatrimestres = 0;
  for(int i = 0; i < estudiante.num_cuatrimestres; ++i)
    sumaNotasCuatrimestres += calcularMediaCuatrimestre(estudiante, i);
  return sumaNotasCuatrimestres / estudiant.num_cuatrimestres;
} 

findstr /N /S "<direccion_que_buscas>" <unidad_disco_duro>\*.txt 

• La opción /N es para que te indique el número de línea en la que se ha encontrado la coincidencia.
• La opción /S es para buscar de forma recursiva en todos los subdirectorios del directorio dado.

findstr /N /S "mi_direccion@loquesea.com" D:\*.txt

const int MIN_NUM_TERMINOS = 0; // Constante para el numero minimo de terminos permitido
const int MAX_NUM_TERMINOS = 15; // Constante para el numero maximo de terminos permitido
 
int main() {
  int terminos;
  do {
    cout << "Introduce el numero de terminos [" << MIN_NUM_TERMINOS << " - " << MAX_NUM_TERMINOS << "]: ";
    cin >> terminos;
  } while(terminos < MIN_NUM_TERMINOS || terminos > MAX_NUM_TERMINOS);
 
  // Cuando llegues a esta linea ya tendras un valor dentro del rango permitido
} 

// Esto:
if(numero > 0 && numero < 15);
else {
  ...
}
// Se puede sustituir por esto:
if(numero <= 0 || numero >= 15) {
  ...
} 

• La primera parte únicamente cambia el signo del elemento. Cuando k es par, el signo es positivo y cuando k es impar el signo es negativo.
• La segunda parte tiene un factorial que puede resultar costoso de calcular. Sin embargo, si en la primera iteración tienes calculado 2!, basta multiplicar por 3 y por 4 para tener 4! y así sucesivamente sin tener que repetir cálculos.
• La tercera parte tiene x^4 en el primer elemento y x^8 en el segundo. En el tercero sería x^12, o lo que es lo mismo en cada iteración se multiplica por x^4. x^4 * x^4 = x^(4+4) = x^8 (propiedades de las potencias)

int main() {
  // Inicializamos el resultado a 0 para poder acumular correctamente
  double resultado = 0;
 
  // Las variables n y x no hace falta inicializarlas porque se van a pedir por teclado
  int n;
  double x;
 
  // Inicializamos las variables para k = 1
  int signo = -1; // (-1)^1 = -1
  double factorial = 2; // (2 * 1)! = 2! = 2
  double elemento3 = pow(x, 4); // x^(4 * 1) = x^4. AVISO: Primero hay que pedir x
 
  for(int i = 1; i <= n; ++i) {
    // Sumamos el elemento i
    resultado += signo * 1/factorial * elemento3;
    // Actualizamos cada uno de los elementos
    signo *= -1; // Asi cambiamos de signo en cada iteracion
    factorial = ...;
    elemento3 = ...;
  }
} 

• Un bloque while() primero comprueba la condición y si esta es cierta entonces ejecuta lo que hay dentro de forma cíclica mientras la condición siga siendo cierta.

while(condicion) {
  // lo que sea
} 

• Un bloque do-while() primero ejecuta lo que hay dentro, después comprueba la condición y si es cierta repite lo que hay dentro de forma cíclica mientras la condición siga siendo cierta.

do {
  // lo que sea
} while(condicion);