International Certification Program Python PDA + Java SE 17 OCP y Spring Professional Develop (Spring Core - Spring Boot)

1.1. Concepts of Algorithm and Their Importance

• Definition of algorithms
• Structure of an algorithm: Input, Process, and Output
• Types of algorithms: iterative, recursive, and algorithmic
• Examples of algorithms in real life

1.2. Computational Thinking and Problem Solving

• Decomposing problems into smaller steps
• Pattern recognition and abstraction
• Structure of the solution: Development and optimization
• Designing efficient algorithms

1.3. Practice: Solving Simple Problems with Pseudocode

• Modeling real problems with pseudocode
• Conversions between pseudocode and flowcharts
• Practical exercise: Developing pseudocode to solve a mathematical problem

2.1. Use Case Diagrams

• Identification of actors
• Main and alternative scenario diagrams
• Extended and general use cases

2.2. Sequence Diagrams

• Representation of interaction between objects and events
• Modeling of data flow and message sequence

2.3. Activity Diagrams

• Representation of activities, decisions, and alternative flows
• Activity diagrams with partitions (swimlanes)

3.1. Data Types and Operators

• Primitive data types: integers, floats, booleans, strings
• Arithemetic, logical, comparison, assignment, and bitwise operators
• Data type conversion (casting)

3.2. Conditional Control Structures and Loops

• Conditional statements: if, else, elif, switch
• Counter-controlled loops: for and while
• Condition-controlled loops: do-while
• Concepts of recursion vs iteration

3.3. Declaration and Use of Functions

• Return and non-return functions
• Parameters by value and by reference
• Nested and recursive functions
• Use of lambda functions

3.4. Practice: Problem Solving with Functions

• Functional decomposition exercises to solve problems
• Code modularization to enhance reusability

4.1. Lists, Tuples, Dictionaries, and Sets

• Basic operations on data structures: creation, updating, deletion
• Advanced methods and operations: append, pop, sort, reverse
• Dictionaries and handling key-value pairs

4.2. Sorting Algorithms (Bubble, Selection)

• Step-by-step implementation of sorting algorithms
• Time and space complexity: O(n^2), O(n log n)
• Comparison between sorting algorithms: efficiency and appropriate usage

4.3. Search Algorithms (Binary, Linear)

• Implementation of sequential search and binary search
• Necessary conditions for using binary search
• Comparison of complexities

4.4. Practice: Implementation of Algorithms in Python

• Exercises on searching and sorting with lists and dictionaries
• Optimization of search code for large volumes of data

5.1. Basic Concepts of Objects and Classes

• Definition of objects, classes, attributes, and methods
• Encapsulation, abstraction, and modularity

5.2. Creation of Objects and Methods

• Creation and use of objects in Python
• Public, private, and protected methods

5.3. Inheritance and Polymorphism

• Concept of inheritance and class reusability
• Overridden methods and polymorphism

5.4. Practice: Modeling Objects and Their Interaction

• Practical exercise to model entities using OOP

6.1. Types of Databases (Relational and Non-Relational)

• Key differences between relational and non-relational databases
• Examples of relational databases (MySQL, PostgreSQL) and non-relational databases (MongoDB)
• When to use a relational database vs a non-relational database

6.2. Database Components: Tables, Rows, Columns

• Definition and creation of tables
• Relationships between tables: one-to-one, one-to-many, and many-to-many
• Data types in SQL: VARCHAR, INT, DATE, etc.

7.1. Entity-Relationship Diagrams

• Definition of entities, attributes, and relationships
• Creation of ER diagrams to represent data models

7.2. Primary and Foreign Keys

• Definition of primary keys and how they ensure record uniqueness
• Foreign keys and their importance in linking tables

7.3. Database Normalization

• Concept of normalization and its levels (1NF, 2NF, 3NF)
• Practical exercises to avoid redundancy in databases

8.1. Creation of Tables and Relationships

• Basic SQL Syntax: CREATE TABLE, ALTER TABLE
• Definition of Constraints (PRIMARY KEY, UNIQUE, NOT NULL)

8.2. SQL Queries: SELECT, INSERT, UPDATE, DELETE

• Read Queries: SELECT with filters, operators, and sorting
• Data Insertion, Modification, and Deletion Queries: INSERT INTO, UPDATE, DELETE

8.3. Aggregate Functions: COUNT, SUM, AVG

• Use of functions to calculate aggregates over data sets
• Data grouping with GROUP BY and filtering with HAVING

• What is Python
• Variables and basic data types
• Reading keyboard input

• Outputs
• Input Collection

• If statement
• Else and elif statements
• And and or operators

• Strings in Python
• String Methods in Python
• String Formatting in Python
• Operators
• Numbers
• Conversion of Strings to Numbers and Use of Absolute Values

• Introduction to lists
• Working with numbers in lists
• Data manipulation in lists

• While
• For
• Dictionaries
• Dynamic programming with dictionaries

• Functions
• Function arguments
• Keyword arguments
• Variable arguments

• Lambdas
• Regular expressions
• Data comprehension

• Classes and objects
• Constructor of a class
• Attributes
• Inheritance
• Encapsulation
• Polymorphism

• How to find errors
• Controlling exceptions
• Generating exceptions

• Working with the file system
• Directories and files
• Create a file, manage files

• Key features of the Java language
• Java technology and development environment
• Running and testing a Java program

• Java classes
• The Main method
• Adding a Main method

• Introducing variables
• Working with strings
• Working with numbers
• Manipulating numeric data

• Working with conditions
• Using IF statements
• Working with a list of items
• Processing a list of items

• Working with objects and classes
• Defining fields and methods
• Declaring, instantiating, and initializing objects
• Working with object references
• Doing more with arrays

• Using the String class
• Using the Java API docs
• Using the StringBuilder class
• More about primitive data types
• More numeric operators
• Promoting and casting variables

• Using methods
• Method arguments and return values
• Static methods and variables
• How arguments are passed to a method
• Overloading a method

• Access control
• Encapsulation

• Relational and conditional operators
• More ways to use IF/ELSE constructs
• Using switch statements
• Using the Netbeans debugger

• Relational and conditional operators
• More ways to use IF/ELSE constructs
• Using switch statements
• Using the Netbeans debugger

• Overview
• Working with subclasses and superclasses
• Overriding methods in the superclass
• Creating and extending abstract classes

• Polymorphism
• Polymorphism in the JDK foundation classes
• Using interfaces
• Local-variable type inference
• Using the List interface
• Introducing Lambda expressions

• Overview
• Propagation of exceptions
• Catching and throwing exceptions
• Handling multiple exceptions and errors

• Packages, JARs, architecture
• Application modification and requirements

• The Module system
• JARs
• Module declarations
• Modular JDK

• Testing code
• JShell basics
• JShell in an IDE

• Functional Interfaces and Lambda Expressions
• Collections Streams, and Filters
• Built-in Functional Interfaces

• Introduction to Modular Programming in Java
• Services in a Modular Application
• Migration to a Modular Application

• Concurrency
• Parallel Streams
• Terminal Operations: Collectors
• Creating Custom Streams

• I/O (Fundamentals and NIO2)
• Secure Coding
• Database Applications with JDBC
• Localization

• What is the Collections Framework?
• Iterators
• Type-Wrapper Classes
• What are Generics?

• Exceptions
• Error handling
• Assertion

• What is the Spring Framework?
• The DI Container
• The Spring Framework History and EcoSystem

• Java configuration and the Spring application context
• @Configuration and @Bean annotations
• @Import: working with multiple configuration files
• Defining bean scopes
• Launching a Spring Application and obtaining Beans

• External properties & Property sources
• Environment abstraction
• Using bean profiles
• Spring Expression Language (SpEL)

• Component scanning
• Autowiring using @Autowired
• Java configuration versus annotations, mixing
• Lifecycle annotations: @PostConstruct and @PreDestroy
• Stereotypes and meta-annotations

• The Spring Bean Lifecycle
• The BeanFactoryPostProcessor interception point
• The BeanPostProcessor interception point
• Spring Bean Proxies
• @Bean method return types

• What problems does AOP solve?
• Defining pointcut expressions
• Implementing various types of advice

• Spring and Test-Driven Development
• Spring 5 integration testing with JUnit 5
• Application context caching and the @DirtiesContext annotation
• Profile selection with @ActiveProfiles
• Easy test data setup with @Sql

• How Spring integrates with existing data access technologies
• Spring's JdbcTemplate
• DataAccessException hierarchy

• Transaction overview
• Transaction management with Spring
• Transaction propagation and rollback rules
• Transactions and integration with other Spring modules

• Introduction to Spring Boot Features
• Value Proposition of Spring Boot
• Creating a simple Boot application using Spring Initializer website

• Dependency management using Spring Boot starters
• How auto-configuration works
• Configuration properties
• Overriding auto-configuration
• Using CommandLineRunner

• Quick introduction to ORM with JPA
• Benefits of using Spring with JPA
• JPA configuration in Spring
• Configuring Spring JPA using Spring Boot
• Spring Data JPA dynamic repositories

• Introduction to Spring MVC and request processing
• Controller method signatures
• Using @Controller, @RestController and @GetMapping annotations
• Configuring Spring MVC with Spring Boot
• Spring Boot packaging options, JAR or WAR