Ficha de revisão: Fundamentals of Programming and Software Design

📋 Course Outline

1. Basic Programming Concepts
2. Data Types and Variables
3. Control Structures
4. Functions and Procedures
5. Object-Oriented Programming
6. Error Handling and Debugging
7. Software Development Lifecycle
8. Version Control Systems
9. User Interface Design

📖 1. Basic Programming Concepts

🔑 Key Concepts & Definitions

• Variable
  A named storage location in memory that holds data which can be changed during program execution.
  Example: x = 5

• Data Types
  Categories of data that determine what kind of value a variable can hold, such as integers, floats, strings, and booleans.
  Example: int, float, string, bool

• Control Structures
  Constructs that control the flow of execution in a program, including conditionals and loops.
  Example: if, for, while

• Function
  A reusable block of code designed to perform a specific task, which can accept inputs (parameters) and return outputs.
  Example: def add(a, b): return a + b

• Syntax
  The set of rules that define the combinations of symbols considered to be correctly structured code in a programming language.

• Algorithm
  A step-by-step procedure for solving a problem or performing a task, fundamental to programming logic.

📝 Essential Points

• Variables store data; their names should be descriptive for clarity.
• Data types define what operations can be performed on data and how much memory it consumes.
• Control structures enable decision-making (if, else) and repetition (for, while).
• Functions promote code reusability and modularity, making programs easier to manage.
• Proper syntax is crucial; errors often occur due to incorrect syntax.
• Algorithms form the basis of program logic, guiding the sequence of operations.

💡 Key Takeaway

Understanding core programming concepts like variables, data types, control structures, and functions is essential for writing efficient, readable, and maintainable code.

📖 2. Data Types and Variables

🔑 Key Concepts & Definitions

• Variable: A named storage location in memory used to hold data that can be changed during program execution.
• Data Type: Specifies the kind of data a variable can hold, such as integers, floating-point numbers, or text.
• Integer: A data type representing whole numbers without decimal points (e.g., 1, -5, 100).
• Float (Floating-Point): A data type for numbers with decimal points (e.g., 3.14, -0.001).
• String: A sequence of characters used to represent text (e.g., "Hello", "123").
• Boolean: A data type with only two possible values: True or False, used for logical operations.

📝 Essential Points

• Variables must be declared with a specific data type before use.
• Data types determine what operations can be performed on the data (e.g., addition on integers, concatenation on strings).
• Type conversion may be necessary when combining different data types (e.g., converting a string to an integer).
• Understanding data types is crucial for efficient memory management and avoiding errors.
• Common data types include integers, floats, strings, and booleans; some languages support additional types like lists or dictionaries.
• Dynamic typing languages automatically determine data types at runtime, while statically typed languages require explicit declaration.

💡 Key Takeaway

Understanding data types and variables is fundamental for writing correct and efficient programs, as they define how data is stored, manipulated, and interpreted during execution.

📖 3. Control Structures

🔑 Key Concepts & Definitions

• Control Structure: A programming construct that determines the flow of execution based on certain conditions or repetitions.
• Conditional Statement: A control structure that executes code blocks based on whether a condition is true or false (e.g., if, else, else if).
• Loop: A control structure that repeats a block of code multiple times until a specified condition is no longer true (for, while, do-while).
• Nested Control Structures: Control structures placed inside other control structures to handle complex decision-making or repeated tasks.
• Break Statement: Terminates the nearest enclosing loop or switch statement prematurely.
• Continue Statement: Skips the current iteration of a loop and proceeds to the next iteration.

📝 Essential Points

• Control structures are essential for creating dynamic and flexible programs.
• Conditional statements enable decision-making based on runtime data.
• Loops facilitate repetitive tasks, reducing code redundancy.
• Proper use of break and continue enhances control flow management within loops.
• Nested structures allow for complex logic but can increase code complexity.
• Understanding scope and flow is crucial for debugging and optimizing control structures.

💡 Key Takeaway

Control structures are fundamental tools that direct program flow, enabling decision-making and repetition to solve complex problems efficiently.

📖 4. Functions and Procedures

🔑 Key Concepts & Definitions

• Function: A block of code that performs a specific task, returns a value, and can be called multiple times within a program.
• Procedure (or Subroutine): A block of code that performs a task but does not return a value; used to organize code and improve readability.
• Parameters: Variables listed in a function or procedure definition that accept input values when called.
• Return Value: The output produced by a function after execution, which can be used elsewhere in the program.
• Scope: The context in which variables are accessible; functions and procedures can have local or global scope.
• Call: The process of executing a function or procedure by referencing its name and providing necessary parameters.

📝 Essential Points

• Functions are used when a value needs to be calculated or retrieved; procedures are used for performing actions without returning data.
• Functions typically have a return type, indicating the kind of value they return (e.g., integer, string).
• Parameters can be passed by value (copy of data) or by reference (direct access to data), affecting how data is modified.
• Proper use of functions and procedures enhances code modularity, readability, and reusability.
• Recursive functions call themselves to solve problems that can be broken down into smaller, similar subproblems.
• Understanding scope is crucial to prevent variable conflicts and unintended side effects.

💡 Key Takeaway

Functions and procedures are fundamental building blocks in programming that organize code into reusable, manageable sections—functions return values, while procedures perform actions without returning data.

📖 5. Object-Oriented Programming

🔑 Key Concepts & Definitions

• Class: A blueprint for creating objects, defining attributes (properties) and methods (functions).
  Example: A Car class with attributes like color and methods like drive().

• Object: An instance of a class; a concrete realization containing specific data.
  Example: A specific red car object created from the Car class.

• Encapsulation: The bundling of data (attributes) and methods that operate on the data within one unit, restricting direct access to some of the object's components.
  Purpose: To protect object integrity and hide internal details.

• Inheritance: A mechanism where a new class (subclass) derives properties and behaviors from an existing class (superclass).
  Example: ElectricCar inherits from Car, adding new features.

• Polymorphism: The ability of different classes to be treated as instances of a common superclass, typically through method overriding, allowing for dynamic method binding.
  Example: A drive() method behaves differently for Car and Bike.

• Abstraction: The process of hiding complex implementation details and showing only essential features of an object.
  Example: Using an interface or abstract class to define common behaviors without specifying how they are implemented.

📝 Essential Points

• Object-oriented programming (OOP) organizes code around objects, which combine data and behavior.
• Classes serve as templates; objects are specific instances.
• Encapsulation ensures data hiding and security.
• Inheritance promotes code reuse and hierarchical relationships.
• Polymorphism allows for flexible and interchangeable object behaviors.
• Abstraction simplifies complex systems by exposing only necessary details.
• OOP principles facilitate modular, maintainable, and scalable code.

💡 Key Takeaway

Object-Oriented Programming models real-world entities through classes and objects, emphasizing encapsulation, inheritance, and polymorphism to create flexible and reusable software components.

📖 6. Error Handling and Debugging

🔑 Key Concepts & Definitions

• Error Handling: The process of anticipating, detecting, and managing errors or exceptions in a program to prevent crashes and ensure smooth execution.
• Exception: An unexpected event or error during program execution that disrupts normal flow, such as division by zero or invalid input.
• Try-Catch Block: A programming construct used to handle exceptions; code within try is executed, and if an exception occurs, control passes to the catch block.
• Debugging: The systematic process of identifying, analyzing, and fixing bugs or errors in code.
• Breakpoint: A marker set in code that pauses execution when reached, allowing inspection of program state for debugging.
• Stack Trace: A report of active stack frames at a specific point in time during program execution, useful for locating the source of errors.

📝 Essential Points

• Proper error handling prevents program crashes and improves user experience.
• Use try-catch blocks to manage exceptions gracefully and maintain program stability.
• Debugging tools like breakpoints and stack traces are essential for locating and fixing bugs efficiently.
• Understanding common exceptions (e.g., NullPointerException, IndexOutOfBoundsException) helps in diagnosing issues quickly.
• Effective debugging involves reproducing errors, analyzing logs, and testing fixes iteratively.
• Always handle specific exceptions before generic ones to provide more precise error management.

💡 Key Takeaway

Robust error handling and systematic debugging are crucial skills for developing reliable software, enabling developers to identify issues quickly and improve program stability.

📖 7. Software Development Lifecycle

🔑 Key Concepts & Definitions

• Software Development Lifecycle (SDLC): A structured process that guides the development, deployment, and maintenance of software systems through defined phases to ensure quality and efficiency.

• Requirements Gathering: The initial phase where stakeholders' needs are collected and analyzed to define the software's functionalities and constraints.

• Design: The process of creating architecture, user interfaces, and system specifications based on gathered requirements.

• Implementation (Coding): The actual development of the software by writing code according to design specifications.

• Testing: The phase where the software is systematically checked for bugs, errors, and compliance with requirements.

• Maintenance: Ongoing support, updates, and improvements after deployment to ensure the software remains functional and relevant.

📝 Essential Points

• SDLC provides a systematic approach to software development, reducing risks and improving quality.
• Common SDLC models include Waterfall, Agile, Spiral, and V-Model, each suited to different project needs.
• Phases are often iterative, especially in Agile, allowing for flexibility and continuous improvement.
• Proper requirements analysis is critical to avoid costly revisions later.
• Testing should be integrated throughout the development process, not just at the end.
• Maintenance accounts for a significant portion of the software lifecycle cost.

💡 Key Takeaway

The SDLC is a structured framework that ensures systematic planning, development, and maintenance of software, leading to higher quality products and efficient project management.

📖 8. Version Control Systems

🔑 Key Concepts & Definitions

• Version Control System (VCS): Software that manages changes to source code over time, allowing multiple users to collaborate and track history.
• Repository (Repo): Central storage location for all project files and their revision history.
• Commit: A snapshot of changes saved to the repository, often with a message describing the update.
• Branch: A parallel version of the project allowing development without affecting the main codebase.
• Merge: Combining changes from different branches into a single branch, integrating new features or fixes.
• Conflict: A situation where changes in different branches overlap, requiring manual resolution during merging.

📝 Essential Points

• VCS enables tracking of every change made to files, facilitating rollback and history review.
• Distributed VCS (e.g., Git) allows each user to have a full copy of the repository, promoting offline work and redundancy.
• Centralized VCS (e.g., Subversion) relies on a single central server for version history.
• Branching supports concurrent development, experimentation, and feature isolation.
• Proper commit messages improve project understanding and collaboration.
• Conflict resolution is crucial during merging to maintain code integrity.

💡 Key Takeaway

Version Control Systems are essential tools for collaborative software development, providing history tracking, branching, and conflict management to ensure efficient and organized code management.

📖 9. User Interface Design

🔑 Key Concepts & Definitions

• User Interface (UI): The space where users interact with a digital device or application, including screens, pages, and controls.
• Usability: The ease with which users can learn, navigate, and operate a user interface effectively and efficiently.
• Accessibility: Designing interfaces that are usable by people with a wide range of abilities and disabilities.
• Consistency: Maintaining uniformity in design elements (colors, fonts, layout) to improve user familiarity and reduce confusion.
• Affordance: Design features that suggest their function, helping users understand how to interact with elements (e.g., a button looks clickable).
• Feedback: Visual or auditory responses that inform users about the result of their actions within the interface.

📝 Essential Points

• Good UI design enhances user experience by making interfaces intuitive, efficient, and accessible.
• Consistency across screens and elements reduces cognitive load and helps users predict outcomes.
• Accessibility considerations include color contrast, font size, and alternative text for images.
• Affordances and feedback guide users seamlessly through tasks, reducing errors and frustration.
• Usability testing is crucial to identify issues and improve interface design before deployment.
• Visual hierarchy and layout influence how users prioritize information and navigate the interface.

💡 Key Takeaway

Effective user interface design balances aesthetics with functionality, ensuring that users can interact effortlessly while the system remains accessible and intuitive.

📊 Synthesis Tables

⚠️ Common Pitfalls & Confusions

1. Confusing variables with constants; forgetting to declare constants as immutable.
2. Using assignment operator (=) instead of comparison operator (==) in conditionals.
3. Mixing data types without proper conversion, leading to runtime errors.
4. Overusing nested control structures, causing complex and unreadable code.
5. Forgetting to initialize variables before use, resulting in unpredictable behavior.
6. Misunderstanding inheritance—assuming subclasses have access to all superclass attributes without proper access modifiers.
7. Neglecting error handling—not anticipating or catching exceptions, leading to program crashes.
8. Confusing procedures (no return) with functions (with return), especially in languages where syntax differs.
9. In object-oriented design, not applying encapsulation, exposing internal data unnecessarily.
10. Ignoring version control best practices—committing incomplete or untested code.
11. Designing user interfaces without considering user experience, leading to confusing or inefficient UI.

✅ Exam Checklist

• Understand the purpose and characteristics of variables and data types.
• Differentiate between static and dynamic typing.
• Explain control structures: conditionals (if, else), loops (for, while).
• Write simple algorithms and translate them into code.
• Define functions and procedures, including parameters and return values.
• Recognize the principles of object-oriented programming: classes, objects, encapsulation, inheritance, polymorphism.
• Describe common error handling techniques and debugging strategies.
• Outline the stages of the software development lifecycle.
• Explain version control systems: purpose, common commands, and benefits.
• Identify key principles of user interface design: usability, accessibility, consistency.
• Write syntactically correct code snippets for basic programming tasks.
• Apply control structures correctly to implement decision-making and repetition.
• Demonstrate understanding of class and object creation, method invocation, and inheritance.
• Recognize common programming pitfalls and how to avoid them.
• Understand the importance of testing and debugging throughout development.
• Describe the role of version control in collaborative programming.
• Design simple user interfaces considering user experience principles.