What this book covers
Chapter 1, Exploring the OutSystems Platform, provides an overview of the base of the OutSystems platform and the characteristics that make it unique. Here, we discover the simplicity with which we can manage our existing development environments and tools.
Chapter 2, Components, Tools, and Capabilities, shows in greater detail the range of features and capabilities provided by the OutSystems platform, from operation and management tools, IDEs, and the strong community component through forums and the Forge.
Chapter 3, Starting Work with OutSystems, introduces the first practical steps so that we can develop our software. We will learn how to register with OutSystems, download the IDEs, and how to initialize them in our personal areas.
Chapter 4, Using Your Modules to Simplify and Encapsulate Your Code, starts with the foundations, as you would for a house, giving an overview of how we should build our software divided into modules and inserted into the layers they correspond to. This step allows us to develop scalable and robust, future-ready software.
Chapter 5, Modeling Data by Using Entities, addresses the fact that applications nowadays live on data. In this chapter, we learn where this data is stored and how we can access and manipulate it. In addition, we learn the terms used to identify each of the components related to the database in OutSystems.
Chapter 6, Server-Side Logic, looks at how modern applications run (in most cases) on the server and on the client (the user's computer browser). In this chapter, we learn what server-side development in OutSystems consists of and how to work on this aspect.
Chapter 7, Exceptions Handling, explains how we should handle anomalous or erroneous behavior in our applications, because things do not always go as expected and it is necessary to predict and deal with cases of failure, such as database errors, access attempts by unauthorized users, or even customized errors.
Chapter 8, Reactive UI Development, explains how to develop the frontend of our web applications within the reactive paradigm. This paradigm is based on the most modern technologies on the market, ensuring safety, performance, and robustness.
Chapter 9, Using Mobile Patterns for Fast Mobile UI Development, looks at the paradigm for mobile application development and how it is very similar to reactive web application development. However, and derived from the characteristics of devices and the use for which they are designed, mobile applications have a different set of points. This chapter focuses on these points in order to allow for an understanding of the differences and why they exist.
Chapter 10, Client-Side Logic, reminds us that we must keep in mind that an application must be composed of not only server-side logic but also client-side logic. This logic allows us to assess the functioning and functionalities of the application, guaranteeing its correct use and always ensuring an excellent user experience. It is in this chapter that we learn about this subject.
Chapter 11, Local Storage and Data Synchronization, deals with a specific case of mobile applications: local storage and how to synchronize data between it and server data. This feature is extremely important these days, as it allows the use of applications even without an internet connection (offline mode) and allows strict management of data that is stored on a less secure device, such as a mobile phone or tablet.
Chapter 12, Debugging and Troubleshooting Mobile and Reactive Web Apps, addresses the questions: Does our application not work? Are we getting errors in certain features? What is up? What is the problem? Calm! The OutSystems platform provides tools to help us! Furthermore, there is a set of basic procedures that are demonstrated in this chapter to facilitate us on this path.
Chapter 13, Designing the Architecture of Your OutSystems Applications, shows us how to create our applications within the standard model recommended by OutSystems: the 3 Layer Canvas, also known as the Architecture Canvas. This model allows the construction of robust, performant, and, above all, highly scalable software. However, we must always remember that architecture is not immutable, and here we understand how easily we can adapt it throughout the life cycle of our applications.
Chapter 14, Integrating OutSystems with Your Ecosystem, looks at how, often in software projects, it is necessary to integrate with other existing systems inside and outside the company's ecosystem. In this chapter, we learn several ways to do this, depending on the technologies of the producer and consumer systems and the planned approach to software development.
Chapter 15, BPT Processes and Timers – Asynchronous Tools in OutSystems, explains what asynchronism is, what tools of this type exist, what they are for, and in what cases we should use them. Here, we understand that we can process logic in programmed time periods and en masse, just as we can control process flows in an isolated and robust way.