Rapid Application Development with OutSystems E-Book

Ricardo Pereira

• Herausgeber: Packt Publishing
• Kategorie: Fachliteratur
• Sprache: Englisch
• Veröffentlichungsjahr: 2022

Seitenzahl: 286

Beschreibung

OutSystems is a software development platform that speeds up the build phase by abstracting code and making almost everything visual. This means replacing textual language with visual artifacts that avoid lexical errors and speed up code composition using accelerators and predefined templates.
The book begins by walking you through the fundamentals of the technology, along with a general overview of end-to-end web and mobile software development. You'll learn how to configure your personal area in the cloud and use the OutSystems IDE to connect with it. The book then shows you how to build a web application based on the best architectural and developmental practices in the market, and takes the same approach for the mobile paradigm. As you advance, you'll find out how to develop the same application, and the great potential of reusing code from one paradigm in another and the symbiosis between them is showcased.The only application that'll differ from the application in the exercise is the one used in business process technology (BPT), with a focus on a common market use case.
By the end of this OutSystems book, you'll be able to develop enterprise-level applications on the web and mobile, integrating them with third parties and other systems on the market. You'll also understand the concepts of performance, security, and software construction and be able to apply them effectively.

Leseprobe

Rapid Application Development with OutSystems

Create applications with OutSystems up to seven times faster than with traditional technologies

Ricardo Pereira

BIRMINGHAM—MUMBAI

Rapid Application Development with OutSystems

Copyright © 2022 Packt Publishing

All rights reserved. No part of this book may be reproduced, stored in a retrieval system, or transmitted in any form or by any means, without the prior written permission of the publisher, except in the case of brief quotations embedded in critical articles or reviews.

Every effort has been made in the preparation of this book to ensure the accuracy of the information presented. However, the information contained in this book is sold without warranty, either express or implied. Neither the author, nor Packt Publishing or its dealers and distributors, will be held liable for any damages caused or alleged to have been caused directly or indirectly by this book.

Packt Publishing has endeavored to provide trademark information about all of the companies and products mentioned in this book by the appropriate use of capitals. However, Packt Publishing cannot guarantee the accuracy of this information.

Associate Group Product Manager: Pavan Ramchandani

Publishing Product Manager: Rohit Rajkumar

Senior Editor: Sofi Rogers

Content Development Editor: Feza Shaikh

Technical Editor: Simran Udasi

Copy Editor: Safis Editing

Project Coordinator: Manthan Patel

Proofreader: Safis Editing

Indexer: Sejal Dsilva

Production Designer: Shankar Kalbhor

First published: January 2022

Production reference: 3080222

Published by Packt Publishing Ltd.

Livery Place

35 Livery Street

Birmingham

B3 2PB, UK.

978-1-80020-875-9

www.packt.com

First of all, I would like to dedicate this book to my wife, Carmen, my son, Afonso, and my daughter, Maria, for being my source of energy and support, for being part of my life, and for all the love they give me.

I would also like to thank all my family, my parents, brother, grandparents, in-laws, brothers-in-law, cousins, and nephew, for believing in me and for all their love. Thanks to my brother from another mother, João Roque, for walking beside me in this adventure that is life.

I would like to give special thanks to Andreia Tulcidás and Ana Lopes from OutSystems, for all their support and help throughout the book's execution process.

Finally, and in a very special way, I wanted to dedicate, in addition to the work of this book, the effort and will, to two very important people in my life who have recently passed away: my grandfather, José Pereira, and my uncle, José Costa Pereira. Thank you for everything you represented to me and for the examples you led that served as a basis for shaping me.

– Ricardo Pereira

Foreword

I have known and worked with Ricardo Pereira for 3 years now. We had the opportunity to work together to deliver OutSystems projects in the banking industry in Portugal and Spain. Being such an important line of business, best practices, solid architectures, and security were always at the top of the requirements list.

Ricardo has been working with OutSystems for quite some time and is now one of the OutSystems Champions worldwide. OutSystems is part of his professional DNA. He breathes it all the time, throughout his professional career.

In Rapid Application Development with OutSystems, Ricardo takes you on an amazing journey through all the important aspects of delivering OutSystems applications to the world. From the basic topics to the more advanced ones, you will be able to fully understand what it's like to build an OutSystems application from scratch.

From architecture and data modeling to logic, services, and the UI, you will find the proposed exercises and examples very useful, to better understand how things are put together. Also, business processes and platform monitoring are an excellent complement to get a clear big picture of what the OutSystems platform is all about.

In this book, Ricardo encapsulates the knowledge gained throughout his most recent professional career. With his words, step-by-step instructions, screenshots, examples, and links to additional sources of information, you will learn how to continuously enhance your skills and apps.

Paulo Moreira

OutSystems Expert, Technical Team Leader at Nexllence, Powered by Glintt

Ricardo Pereira is one of the most active members of the OutSystems community. He is a professional developer of reactive web applications and has been active in the OutSystems community since 2016, contributing to us and supporting many developers. He has about 400 Kudos for solving issues and providing information in the forum. Ricardo has been recognized for his work and is now an OutSystems Champion, an officially recognized OutSystems Community Advocate.

This book, written by a man with a real wealth of knowledge and experience, provides an easy-to-understand overview of the know-how needed to develop applications with OutSystems. In this book, you will learn about the basics of the OutSystems platform, the necessary tools and components, application development methods, how to implement your own logic, how to implement server-side and client-side logic, data modeling, exception handling, UI design, debugging, and more. OutSystems is a cool low-code development tool, but using it effectively requires knowledge of software application development as well as OutSystems’ own terminology. This book is a must-read for developers who will be using OutSystems to develop applications.

OutSystems has many experts like Ricardo in its user community (OutSystems User Groups). This is a great honor for us. I hope that Ricardo’s book will be of help to many developers.

Taiji Hagino

Lead Community Manager, Developer Advocate at OutSystems

Contributors

About the author

Ricardo Pereira is passionate about programming, software, and technology. Coming from a computer science background, he has become, in the last 5 years, a strong bettor on OutSystems learning, holding all existing certifications of the platform. Furthermore, in 2020, he was named OutSystems Champion, participating in several events and following the mentoring program as a mentor. His time is distributed between software projects, learning, studying, and spending time with family.

Ricardo lives with his wife and their two children in Vila Nova de Gaia, Portugal. His greatest influence in the relentless pursuit of continuous improvement and being the best version of himself is his grandfather.

This book was driven by Packt's invitation, as I had never considered writing anything. I've always been passionate about what I do, programming, for OutSystems, but only after the invitation did I realize that I could share everything I have learned and experienced in this technology in a much broader way. For all this, I would like to thank Packt and the entire team involved in the process for believing in me, for the fantastic help they gave, and for being the wonderful people they are.

About the reviewers

João Martins Pereira is an experienced senior developer who works for a large UK company and has been using OutSystems technology since 2016.

His background includes working with Python, SQL, and JavaScript but mainly integrating with the OutSystems platform.

Delivering projects and dealing with different clients around the globe, he has had the opportunity to work with several applications, such as traditional web, web reactive, and mobile applications in several core businesses.

He got the opportunity to attend the NextStep Denver 2019 conference as a speaker, talking about mobile synchronization patterns for large volumes of data.

Mariano Picco is an OutSystems expert, with experience in application architecture, specializing in scalable solutions and integrations. He is particularly interested in the optimization of solutions and the role of low code in the software industry. You can often find him trying to collaborate and participate in the community forums.

Paulo Moreira, born in Portugal's capital, Lisbon, started his professional career with an airline company, back in 1988. While working as an aircraft maintenance technician, this was when IT was first introduced to him as a potential future career. And so it happened.

He bumped into OutSystems a while later, in 2008, and since then it has been a permanent presence in his professional career.

Again, (re)starting as a junior developer, Paulo quickly improved his technical skills with this low-code platform, on all skill sets applicable, including development, delivering, engaging, and more recently, training.

He's currently a technical team leader at Nexllence, where he's also in charge of the OutSystems team's talent and training.

Table of Contents

Preface

Section 1: OutSystems 101

Chapter 1: Exploring the OutSystems Platform

Platform overview

Platform server

Service Studio

Integration Studio

Service Center

Publishing an application

Monitoring and logging

Distribution

Cache

SEO – Search Engine Optimization

OutSystems factory options

OutSystems platform deployment options

External tools, components, and support

Forge and Community

Summary

Chapter 2: Components, Tools, and Capabilities

Service Studio walkthrough

The Data tab

The Logic tab

The Interface tab

The Processes tab

Service Center capabilities

The Factory tab

The Monitoring tab

The Administration tab

The Analytics tab

Managing your infrastructure with LifeTime

Managing end users with the Users application

Integration Studio walkthrough

Summary

Chapter 3: Starting Work with OutSystems

OutSystems pricing and editions

Setting up our Personal Environment

Installing OutSystems IDEs

Opening and starting Service Studio

Opening and starting Integration Studio

Summary

Section 2: The Magical Path of the Backend

Chapter 4: Using Your Modules to Simplify and Encapsulate Your Code

Technical requirements

Types of modules

Distributing modules across applications

Applying modules to the correct architecture layers

Foundation layer

Core layer

End user layer

All layers

Modules and application naming convention

Summary

Chapter 5: Modeling Data by Using Entities

Technical requirements

Exploring database Entities

What are Static Entities?

Modeling data

Bootstrapping data into Entities from an Excel spreadsheet

Exercise 1 – creating a data model

Summary

Chapter 6: Server-Side Logic

Technical requirements

Introducing logic actions

Types of variables in Server Actions

Taking logic decisions with conditional paths

Creating loops

Exercise 2 – Creating server actions

Summary

Chapter 7: Exceptions Handling

Technical requirements

Raising Exceptions

Exception handler flows

Global Exception handler

Exercise 3 – raising and handling an Exception

Summary

Section 3: Create Value and Innovate with the Frontend

Chapter 8: Reactive UI Development

Technical requirements

Reactive patterns and templates

Reactive widgets

Scaffolding screens

CSS themes and styles

JavaScript in OutSystems

Screen and block lifecycle events

Events to propagate changes from a block to the parent

Exercise 4 – Creating application screens

Summary

Chapter 9: Using Mobile Patterns for Fast Mobile UI Development

Technical requirements

Patterns, templates, and widgets

Mobile design considerations

Process and concept

Target audience

Design

Security

Performance

Mobile plugins

Adding plugins to our applications

Native app generation

Exercise 5 – Creating mobile app screens

Summary

Chapter 10: Client-Side Logic

Technical requirements

Screen Client Actions

Data actions

Client logic actions

Exercise 6 – creating Client Actions and using them on the frontend

Summary

Chapter 11: Local Storage and Data Synchronization

Creating and using Local Storage entities

Fetching data from Local Storage

Analyzing data synchronization patterns

Summary

Chapter 12: Debugging and Troubleshooting Mobile and Reactive Web Apps

Debugging reactive web applications

Debugging native mobile applications

Using Service Center logs to support troubleshooting

Summary

Section 4: Extensibility and Complexity of the OutSystems Platform

Chapter 13: Designing the Architecture of Your OutSystems Applications

The importance of architecture

The 3 Layer Canvas (Architecture Canvas)

The architecture design process

Summary

Chapter 14: Integrating OutSystems with Your Ecosystem

Creating your own C#/.NET code and using it inside the OutSystems platform

Connecting with external databases

Connecting with other systems through web services (REST/SOAP)

Consuming SOAP

Exposing SOAP

Consuming REST services

Exposing REST

Summary

Chapter 15: BPT Processes and Timers – Asynchronous Tools in OutSystems

Process BPT overview

Timers and how they work

BPTs versus Timers

Monitoring Processes and Timers

Summary

Other Books You May Enjoy

Preface

OutSystems is a software development platform that speeds up the build phase by abstracting code and making almost everything visual – this means replacing textual language with visual artifacts that avoid lexical errors and speed up code composition using accelerators and pre-defined templates.

The book begins by walking you through the fundamentals of the technology, along with a general overview of end-to-end web and mobile software development. You'll learn how to configure your personal area in the cloud and use the OutSystems IDE to connect with it. The book then shows you how to build a web application based on the best architectural and developmental practices, and takes the same approach for the mobile paradigm. As you advance, you'll find out how to develop the same application, and showcase the great potential of reusing code from one paradigm in another and the symbiosis between them. The only application that'll differ is the one used in BPT (Business Process Technology), with a focus on a common market use case.

By the end of this OutSystems book, you'll be able to develop enterprise-level applications on the web and mobile, integrating them with third parties and other systems on the market. You'll also be able to understand the concepts of performance, security, and software construction and apply them effectively.

Who this book is for

This book is for backend developers, tech leaders, UX/UI developers, frontend developers, (in general, full-stack developers), tech companies, and enterprises looking to learn how to develop web and mobile software quickly and disruptively by leveraging OutSystems, one of the most low-code platforms on the market. An IT background is not mandatory; however, experience in SQL, JavaScript, HTML, CSS, and C# is required to get started with this book.

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.

To get the most out of this book

You must have installed Visual Studio Community for the C#/.NET native code integrations component discussed in Chapter 14, Integrating OutSystems with Your Ecosystem.

In addition, you must have installed the Service Studio 11.50.9 (or above) and Integration Studio 11.10.18 (or above) IDEs. All code demonstrated was tested using these versions. Installation of these IDEs is demonstrated in Chapter 3, Starting Work with OutSystems.

The use of Integration Studio is only possible in a Windows environment, as this IDE does not exist for the macOS environment.

Code in Action

The Code in Action videos for this book can be viewed at https://bit.ly/3D1S9bX.

Download the color images

We also provide a PDF file that has color images of the screenshots and diagrams used in this book. You can download it here:

https://static.packt-cdn.com/downloads/9781800208759_ColorImages.pdf

Conventions used

There are a number of text conventions used throughout this book.

Code in text: Indicates code words in text, database table names, folder names, filenames, file extensions, pathnames, dummy URLs, user input, and Twitter handles. Here is an example: "Create a new Reactive Web application and name it Help Desk."

Bold: Indicates a new term, an important word, or words that you see onscreen. For instance, words in menus or dialog boxes appear in bold. Here is an example: "Now, we select the tab Data, expand the entity Ticket, and drag the CRUD CreateOrUpdateTicket to the flow."

Tips or important notes

Appear like this.

Get in touch

Feedback from our readers is always welcome.

General feedback: If you have questions about any aspect of this book, email us at [email protected] and mention the book title in the subject of your message.

Errata: Although we have taken every care to ensure the accuracy of our content, mistakes do happen. If you have found a mistake in this book, we would be grateful if you would report this to us. Please visit www.packtpub.com/support/errata and fill in the form.

Piracy: If you come across any illegal copies of our works in any form on the internet, we would be grateful if you would provide us with the location address or website name. Please contact us at [email protected] with a link to the material.

If you are interested in becoming an author: If there is a topic that you have expertise in and you are interested in either writing or contributing to a book, please visit authors.packtpub.com.

Share Your Thoughts

Once you've read Rapid Application Development with OutSystems, we'd love to hear your thoughts! Please click here to go straight to the Amazon review page for this book and share your feedback.

Your review is important to us and the tech community and will help us make sure we're delivering excellent quality content.

Section 1: OutSystems 101

In this section, we will find out how an OutSystems framework is composed, how to use it, and what tools we have available to make the most of it.

This section comprises the following chapters:

Chapter 1, Exploring the OutSystems PlatformChapter 2, Components, Tools, and CapabilitiesChapter 3, Starting Work with OutSystems

Chapter 1: Exploring the OutSystems Platform

After all, what is OutSystems?

We will provide a quick overview of what their components and tools are and how they work, as well as all the capabilities and potential of the OutSystems platform.

The OutSystems platform enhances and accelerates the development and delivery of enterprise-level web and mobile applications, always with the guarantee of following the best standards of security and performance available on the market.

All of this is possible because it is made available through low-code development environments, while code is generated that will be made available for an enterprise-level, full stack system.

The platform integrates with other systems in a very practical and simple way, namely, existing databases and legacy applications used by the companies themselves or even with existing code.

Out-of-the-box management and analysis tools regarding the applications developed and existing users are made available so that everything can work as expected.

In this chapter, we will have the opportunity to visualize the different features and capabilities of the OutSystems platform at a high level, as well as existing tools and built-in elements such as Service Center, LifeTime, Service Studio, and Integration Studio.

As expected, topics such as connection and integration with existing systems will be addressed using Service Studio, a modern development interface based on the Visual Code paradigm used to create applications in record time, or with Integration Studio, a great interface development that allows us to create our connections to external databases and create our native C#/.NET code to use services from legacy systems. After being created in this powerful tool, applications are then compiled based on standard and optimized code, such as HTML, CSS, JavaScript, and .NET.

These applications are made available on the different OutSystems environments in a continuous approach, following the best CI/CD practices. Code is constantly inspected and analyzed for impacts, and there is zero downtime when promoting applications to the next environment.

In addition to all this, the OutSystems platform can be deployed both in the cloud and on-premises, enabling the availability of applications in any type of infrastructure.

Are you curious? Do you want to take up the challenge? So, let's get started!

We will cover topics from the platform server to development tools, more specifically, the Service Studio and Integration Studio. The administration and operation tools of the framework will also be addressed, namely, Service Center and LifeTime.

As a bonus, we will provide an overview of OutSystems Forge and Community, helping to understand how these resources can be useful in application development.

So let's get started!

The following topics will be covered in this chapter:

Platform overviewOutSystems factory optionsExternal tools, components, and support

Now let's dive deeper into the OutSystems platform and understand the capabilities and features provided by it.

Platform overview

First, we should realize that there are two possible contexts for working in OutSystems:

Personal Environment: OutSystems offers a small software factory free of charge (in the cloud) so that we can do our exercises, tests, and small applications without a productive context.Enterprise: Licensed software factories for companies. It can exist in the cloud (AWS), private cloud, or on the company's own physical servers (on-premises). Enterprise versions can exist in different types of licensing and are paid.

We will be able to see this issue in more detail in Chapter 3, Starting Work with OutSystems.

All these tools exist both in personal environments and in enterprise factories. In personal environments, there is a set of restrictions and limitations of services and features, from the number of environments available and the space available in the database to the number of IT users allowed.

Whenever we think of an enterprise environment, we are aware that there must be non-productive and productive environments, the most common model being that of three environments:

DevelopmentQuality AssuranceProduction

All existing tools can connect to the environments that make up the OutSystems infrastructure, allowing you to perform any type of necessary task, without, in most cases, the use of external tools.

Platform server

The Platform server is composed of a set of servers (which can be installed both in the cloud and on-premises) that perform all the necessary operations so that the developed applications are available to users. These operations are as follows:

CompileDeployManageRunMonitor

To develop our applications, we can connect to the platform server using Service Studio and Integration Studio. After development, we can publish our applications, and the platform server handles the operations necessary to make the applications available to users.

When we publish an application, the platform saves the version of it in its database, thus creating a repository of versions and backups. During publication, the platform will compile, optimize the code, and make it available on the servers for use.

Application servers use traditional databases and conventional external systems to run applications, thereby ensuring uniformity and standardization.

The following screenshot shows the OutSystems environment ecosystem:

Figure 1.1 – OutSystems ecosystem

As we can see, the ecosystem has all the characteristics of a state-of-the-art model while maintaining simplicity for those who develop applications or manage the platform. To take advantage of this ecosystem, we need to have agile tools at our fingertips, both to develop applications and to manage them and the ecosystem itself. And that's what we've already followed!

Service Studio

Service Studio is the visual OutSystems IDE. Its use is related to the low-code paradigm, reducing the use of textual code as much as possible, reducing the error factor, and thus offering the opportunity for the developer to focus more on the business itself. Using this same tool, we can develop both our web and mobile applications.

This tool addresses four layers of application development:

DataLogicFrontendProcesses

In addition, it provides a section called TrueChange, where the entire analysis of the code is reported, providing detailed information on existing errors and warnings.

The following screenshot shows the look and feel of Service Studio:

Figure 1.2 – OutSystems Service Studio canvas look and feel

OutSystems main application development tool manages to be super intuitive and provides us with numerous accelerators that we can take advantage of. However, this is not all!

Integration Studio

Do you need to create your own custom C #/.NET code? Do you need to connect with external databases? Do you need to create a connection with your legacy systems? Then this is your tool!

Integration Studio offers a set of accelerators to support our native C # code, as well as integrations with databases external to the platform, making these routines simple and easily scalable.

After creating our code and our integrations, Integration Studio, together with the platform server, creates its representations in the OutSystems universe, thereby being available for use in the same visual paradigm with which we develop our OutSystems applications.

The following screenshot shows the look and feel of Integration Studio:

Figure 1.3 – OutSystems Integration Studio look and feel

With the tools presented, we found out which path to take to develop and make reactive web and mobile applications available at the speed of light. Now, how can we manage and operate the application server? With the next tools!

Service Center

Service Center is a web console that allows you to manage an OutSystems environment, including parameterization, the inspection of logs, and viewing existing applications and the current status of existing services, thereby facilitating the export of generated event reports. The following screenshot shows the look and feel of Service Center:

Figure 1.4 – OutSystems Service Center look and feel

Service Center guarantees us a very practical control of each of our environments. However, OutSystems wanted to go further and complemented this tool with the one we'll demonstrate next, taking the power and ease with which we can master our platform even further.

LifeTime

We are going to visualize a kingdom, composed of several layers, and at the top there is someone on a throne. Is it displayed? Whoever is on the throne is called LifeTime!

LifeTime, also a web console, allows you to control, monitor, and configure the complete life cycle of our applications between the multiple environments in the framework. With this, this tool allows you to go further than we can through Service Center.

With this console, we are able to deploy the different applications existing in the OutSystems infrastructure, benefiting from multiple integrity checks to guarantee the stability and robustness of the environments. In addition, the deployments made by LifeTime guarantee "zero downtime," translating this into a better experience for the end user since, in this way, applications are never unavailable.

In addition, LifeTime allows you to track versions of our applications, and we can customize their tags at the time of deployment (if we do not, LifeTime does it for us).

Another fantastic feature that exists in LifeTime is the ability to manage the permission levels of each IT user and development team, thus ensuring the ownership of each of the existing workstreams.

The following screenshot shows the look and feel of LifeTime:

Figure 1.5 – OutSystems LifeTime look and feel

As we can see, OutSystems allows us, in addition to having great power and control over all aspects of the platform, to do so responsibly, with guarantees to maintain the correct functioning and abstracting from the high complexity that a system of this category has. Everything is much simpler, more practical, and more effective.

Next, we will analyze the functionalities and capabilities that the OutSystems platform makes available to us in order to facilitate and accelerate our work, thereby ensuring that we have a greater focus on the business and its needs.

With this information in mind, a pertinent question arises: How do we publish our applications to our servers?

Publishing an application

We know that if we want to have our applications fully available and make the most of our infrastructures, we will want to publish them on all our frontend servers to process all requests coming from browsers or mobile devices in an identical manner. In the example of three frontend servers, did we need to publish the application three times (once on each server)?

The answer is no! OutSystems tools such as Service Studio, Integration Studio, and Service Center provide the 1-Click Publish functionality, which basically triggers the action of publishing in the corresponding environment. In addition, this feature manages to do it in style: with so-called zero downtime! Applications are never unavailable during the publishing process, minimizing the impact on their users. This feature is achieved by publishing the necessary files in a virtual directory, and when the operation is complete, the old directory is replaced in its entirety by the new one. This whole process is called hot deployment.

To obtain this behavior, there is a server called Deployment Controller Server that has installed the Deployment Controller Service service (it does not need to be a dedicated server; this service can be installed on one of the frontend servers, assuming the same two roles) that communicates with all other frontends through their deployment services.

In summary, we press the 1-Click Publish button, which saves a new version of our module, generates and compiles optimized code and SQL scripts, and updates the database model until it finally deploys the application.

The following screenshot shows the application publishing flow from Service Studio:

Figure 1.6 – OutSystems application publishing flow from Service Studio

The publishing flow of an application is done in a fully controlled way to ensure that everything is ready and without generating any issues regarding the use of our applications. Even so, it may be necessary to check events to ensure that everything runs smoothly. Monitoring? Logging? Of course these functions are available!

Monitoring and logging

The OutSystems platform provides an automatic monitoring service for our applications. This means that any event is recorded in databases so that we can search for them in the future. To this end, an asynchronous approach was applied to the writing of the logs. If they were recorded in real time, we would have a performance problem because we have lots of logs to be written simultaneously in the database, thereby causing delays and possible locks on the tables. We can imagine an application with hundreds or thousands of users at the same time… anything could go wrong (Murphy's law always comes up).

And how does asynchronous logging work? To this end, each frontend server has a logging service. The logs are transmitted to the Microsoft Message Queuing (MSMQ)by the service center of the respective server, and they are subsequently captured by the log service from time to time which, in turn, inserts the data in bulk (bulk insert) in the respective database tables. These same tables, to ensure the best possible performance in writing, do not use indexes (indexes are very useful and optimize performance in research, but slow down writing).

Well, throughout