PowerBuilder

PowerBuilder (Advanced)

These concepts cover PowerBuilder's most advanced features and architectural considerations. They are necessary for designing and maintaining large-scale PowerBuilder applications and systems.

1. Using the SQL Select Data Source
   • Learn to write and use SQL queries to fetch data from the database, which can be used in DataWindow objects.
   • Explore how to configure various properties of DataWindow objects to adjust their appearance and behaviour.
   • Reason: SQL queries are necessary for retrieving specific data sets to be displayed in DataWindows.
   • Example Task: Write an SQL query, adjust DataWindow properties to select specific records from a database table, and use them in a DataWindow object.
2. Modifying the Presentation of the Result Set​​​​​​​​​​​​
   • ​​​​​​​Understand how to modify the layout of DataWindows to better present data according to user requirements.
   • Learn to apply various formatting options to DataWindows to enhance the visual appeal and readability of data.
   • Reason: Custom layouts make data more accessible to understand and interact with.
   • Example Task: Apply Modify the layout and formatting of a DataWindow to add or rearrange columns and adjust their formatting.
3. Writing Basic Database Connection and Disconnection Logic
   •  Learn to write scripts for establishing and managing database connections within your PowerBuilder application.
   • Understand how to handle database disconnections and ensure resources are released correctly properly.
   • Reason: Effective connection management ensures smooth data operations and resource handling.
   • Example Task: Implement a script close database connection, to establish a database connection and handle potential connection errors.
4. Completing Application Sheets
   • ​​​​​​​Learn to design and configure DataWindow controls to display and interact with data effectively within your application.
   • Explore how to bind DataWindow controls to data sources to display and update data dynamically.
   • Reason: Proper design of DataWindow controls ensures that users can view and manage data efficiently.
   • Example Task: Design DataWindow controls with various presentation styles and Bind a DataWindow control to a data source, ensuring they meet application requirements.
5. Inserting and Deleting Data
   • Learn how to implement functionality to insert new records into the database using DataWindow objects.
   • Explore techniques for deleting records from the database and ensuring that DataWindows reflect these changes.
   • Reason: Inserting new data is essential for maintaining and expanding the database.
   • Example Task: Write a script to insert new, delete existing records into a database table and use a DataWindow to facilitate this operation.
6. Saving Data to the Database & Handling Errors
   • Understand how to save changes made in DataWindows back to the database to ensure that user modifications are persisted.
   • Learn to handle errors that occur during save operations to ensure data integrity and user awareness of issues.
   • Reason: Proper error handling during data saving ensures that users' updates are stored in the database and available for future use. 
   • Example Task: Implement error handling for save operations and provide appropriate feedback to users if an error occurs. Handle division by zero errors using TRY...CATCH blocks
7. Creating Custom Class User Objects
   • Learn how to create and use custom class user objects to extend the functionality of your PowerBuilder applications.
   • Explore how to use and integrate custom class user objects into your application to enhance its functionality.
   • Reason: Custom class user objects allow you to define new classes with specific behaviours and properties.
   • Example Task: Create a custom class user object that includes methods for managing application-specific data.
8. Communicating Between Objects
   • Learn about message passing techniques to enable communication between different objects in PowerBuilder.
   • Explore using message objects to handle and process messages sent between various application components.
   • Reason: Effective message passing is crucial for coordinating interactions and data exchange between objects.
   • Example Task: Implement a message-passing mechanism to update the status of a form based on events from another object.
9. Passing NVOs to Message Objects
   • Learn about non-visual objects and their role in managing application logic and data processing.
   • Explore techniques for passing NVOs between application parts to facilitate data handling and interactions.
   • Reason: NVOs provide a way to encapsulate functionality and manage data without directly interacting with the user interface.
   • Example Task: Pass an NVO to a message object for data processing or business logic.
10. Enabling Data Window Functionality
    • Learn how to create master-detail DataWindows to display related data in a parent-child relationship.
    • Explore techniques for sorting and filtering data on the client side to enhance data interaction and user experience
    • Reason: Master-detail interfaces allow users to view and interact with related data efficiently.
    • Example Task: Implement a master-detail DataWindow where selecting a master record displays corresponding detail records. Implement client-side sorting and filtering features.
11. Implementing Application Security
    • Learn to implement user authentication and role-based access control, as well as secure data and communication channels.
    • Learn to create and manage custom events and implement handlers to address user interactions and application events.
    • Reason: Ensuring security is vital for safeguarding sensitive data and maintaining the integrity of the application
    • Example Task: Develop and integrate user authentication and role-based access controls into a PowerBuilder application.
12. Advanced Event Handling
    • Learn to create and manage custom events and implement handlers for user interactions and application events.
    • Explore asynchronous event handling to boost performance and responsiveness. Implement handlers for non-blocking operations.
    • Reason: Mastering advanced event-handling techniques is crucial for building responsive and interactive applications.
    • Example Task: Design and implement custom event handlers to manage complex user interactions within a PowerBuilder application.
13. Version Control 
    • Using version control systems (VCS) with PowerBuilder using GIT or SVN.
    • Branching, merging, and resolving conflicts.
    • Reason: Version control is essential for managing code changes and collaboration.
    • Example Task: Set up a Git repository for a PowerBuilder project and demonstrate basic version control operations.
14. Setting Up CI/CD Pipelines for PowerBuilder Applications
    • Implement continuous integration and continuous deployment (CI/CD) to streamline and automate the testing and release process for PowerBuilder apps.
    • Automated testing and deployment.
    • Reason: CI/CD practices ensure consistent and reliable application delivery.
    • Example Task: Configure a CI/CD pipeline for a PowerBuilder app using Jenkins or similar tools to automate build, test, and deployment stages.
15. Agile methodologies in Projects 
    • Learn Agile methods for effective PowerBuilder project management, including setting milestones, managing resources, and tracking progress.          
    • Learn to structure and manage large PowerBuilder projects, focusing on handling complexity and team coordination.
    • Reason: Effective project management ensures timely delivery and successful completion of complex projects.
    • Example Task: Develop a project plan using Agile methodologies for an extensive PowerBuilder application, including defining sprints and tracking progress.
16. Deploying an application
    • Learn the steps and best practices for deploying PowerBuilder applications to production environments.
    • Explore configuring various deployment settings, such as connection strings and environment-specific configurations.
    • Reason: Proper deployment ensures that applications are correctly installed and configured for end-users.
    • Example Task: Prepare an application for deployment setting, including packaging, configuration, and testing.