International Certification Program Programmer Fundamentals + Python PDA + Java Se 17 OCP and 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  

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

1.3. Practice: Solving Simple Problems with Pseudocode  

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

2.1. Use Case Diagrams  

• Identification of actors  
• Diagrams of main and alternative scenarios  
• 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 improve 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 use  

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

• Syntax  
• Operators  
• Variables  
• Control Structures  
• Language Builders and Functions  
• Namespaces  
• Extensions  
• Config  
• Performance Cache / Bytecode

• Arguments  
• Variables  
• References  
• Return  
• Variable scope  
• Anonymous functions, closures  
• Write declaration

• Introduction to XML  
• SimpleXml  
• XML Extension  
• Introduction to Web Services  
• SOAP  
• JSON  
• DateTime  
• DOMDocument

• Sessions  
• Forms  
• Data Sent via GET and POST  
• Cookies  
• HTTP Headers  
• HTTP Authentication  
• HTTP Status Codes

• Instantiation  
• Modifiers / Inheritance  
• Interfaces  
• Return Types  
• Autoload  
• Reflection  
• Type Hinting  
• Class Constants  
• Late Static Binding  
• Magic Methods (_ *)  
• Instance, Methods, and Properties  
• Standard PHP Library (SPL)  
• Traits

• Configuration  
• Session Security  
• XSS - Cross-Site Scripting  
• CSRF - Cross-Site Request Forgeries  
• SQL Injection  
• Remote Code Injection  
• Email Injection  
• Filter your input / escape your output  
• Encryption and Hashing Algorithms  
• File Uploads  
• PHP Configuration  
• Password hashing API

• Files  
• Reading  
• Writing  
• File system functions  
• Streams  
• Contexts

• String Delimiters  
• Comparisons  
• Extractions  
• Searches  
• Substitutions  
• Formatting  
• Perl Compatible Regular Expressions (PCRE)  
• HEREDOC and NOWDOC  
• Character Encodings

• SQL  
• JOINS  
• Prepared Statements  
• Transactions  
• PHP Data Objects (PDO)

• Associative arrays  
• Traversing an array  
• Array functions  
• SPL, objects, and arrays  
• Casting

• Exception Handling
• Errors
• Throwables

• 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
• Overloading constructors

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

• Working with dates  
• Parsing the args array  
• Two-dimensional arrays  
• Alternate looping constructs  
• Nesting loops  
• The ArrayList class

• 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
• Assertions

• 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 @Sq

• 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 testing

• 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