Welcome to the OutSystems Overview Section. In this section
we'd like to cover a number of topics including answering the question "What is
OutSystems 10?" and "What of the components and tools that OutSystems provides?" and
that includes the core OutSystems server, our development tools, some
administration and operations tools, as well as resources that are available
from the community. So we'll talk about all of those and we'll also briefly talk
about the server architecture itself and how apps get deployed. So let's go ahead
and get started. OutSystems 10 delivers enterprise Web and mobile applications
very quickly. It is a low-code development environment that is enterprise grade and
is a full stack system. It has the capability of being extended, and it
can integrate with any kind of existing systems that you might have, and it also
has built-in management and analytics. So OutSystems 10 is a complete system that
helps us develop things and deploy them very very quickly. Now OutSystems has
recently gotten a lot of analysis from different types of analysts and Forrester
has published their latest Forrester Wave for low-code platforms and OutSystems
is one of the leaders -- you can see that in the leader wave OutSystems is here
at the top and there are a lot of people entering the low-code platform, OutSystems
has been doing this for quite a while and has a really nice platform for us to
work with. Gartner has also been working on their Mobile Application Development
Platform Magic Quadrant and in their latest Magic Quadrant OutSystems
appeared as a visionary and since this was the first time that OutSystems was
evaluated and placed inside of the Magic Quadrants to start as a visionary
instead of a niche player or challenger is very unusual and you can see that OutSystems
is right in the middle of lots of people that do mobile application
development and will continue to progress as things go on.
So when we think about OutSystems we want to make sure that there are
different types of development capabilities so we're going to go
through all of the things that you might think about for a development platform
to have for you.
So one of the first things that is very important is you want to be able to
reuse your existing code, so whether you've created APIs or you have some of
your own code that you've created, you definitely don't want to lose the things
that you've invested in, and from there you'd like to be able to extend those
things so the OutSystems visual design approach will help you go ahead and
define different types of data and logic and extend that type of experience. So to
start with you can go ahead and import data from other types of systems from
other databases or you can go ahead and define your own data structures inside
of OutSystems and work with them from there. You can also take logic and begin
building logic and business processes into OutSystems as well. And then
finally from a user interface perspective we can go ahead and build
Web interfaces or mobile interfaces and deploy those with our applications. Now
once we do deploy the applications, the applications get code generated and the
generated code can either be Java or the .Net platform so it is standard optimized
code and when we do some of the client-side things inside of devices
we're using JavaScript and once we deploy we will go ahead and begin working with
the code, so during the deployment phase we would go ahead and take one of the
versions of code and push it to a particular server. When that happens
sometimes we have different types of applications that may have dependencies
on other types of applications so it guarantees the integrity of what we're
doing and it governs all of the steps of the process so that the right people
have access to, and are able to, move things between environments so
developers may be limited administrators can do a little bit more, the operations
team has different types of security, so that we can govern all of these
processes. And we also want to be able to monitor our applications so we know how
well they perform, if they're having any problems and be able to sort of see the
lifecycle of what is going on. Now when we build these apps we want them to be
able to be available in the cloud or on-premises or a mixture of the two, so
OutSystems provides the capability for all of those to occur and as you update
your apps you'll be doing continuous integration where the changes will
happen inside the visual environment, will go through this process again, and
will constantly be tracking the versions and the capabilities of our applications.
So given that we have those capabilities what are the components and tools that
give us those things?
Well, inside of OutSystems there are a number of components and tools that are
available, you can see here that we have our Service Studio environment, we have a
Service Center, Lifetime, Integration Studio and the overall OutSystems
server. So when we have those tools available we will have a typical set of
development environments. So we will have a development environment with a quality
assurance environment and a production environment and you can have more than
this.
These are the typical three that most people refer to but we could have more
environments than this if we need and that means that the OutSystems has the
capability of helping us move our applications in between the different
environments that are created.
So if we start by thinking about the main server we have the OutSystems
server which is the set of servers that can compile, deploy, manage and then run
our applications, as well as monitor them. So the OutSystems server itself sort of
sits above one of the application servers and that could be something like
a Java or .Net server and it gathers all of the information and deploys the apps
that we need, as well as tracking the data in any external systems. So to be
able to do development we would be using Service Studio. It's the development
environment for our Web and mobile applications and when we get inside of
Service Studio we find it to be a low-code visual environment that shows us
what's going on and it enables developers to rapidly create really
great apps, whether they be mobile apps or Web apps. So your typical type of
Integrated Development Environment that will allow us to see the properties and
the different resources that we're working with. Now there's a second set of
development tools called Integration Studio. We said that OutSystems is
extensible and that if we want to be able to reuse some of the existing code
that we already have we might want to be able to do that. Integration Studio
allows us to integrate with different types of existing data or code from Java
or .Net, so if there are databases that we'd like to connect to and be able to
access their data there is a special wizard and connector to go ahead and
help us with the data there's also different types of wizards that will
help us import either .Net assemblies or different types of Java libraries and
once we do those things Integration Studio begins displaying them in a way
that makes sense from an OutSystems perspective. Inside of OutSystems we'll be
working with different types of entities, we'll have different data structures and
actions that we may wish to be able to work with, and all of those will be
defined in Integration Studio and this will help bundle the things that are
extensible and the things that are in
the normal code and be able to make them available to the OutSystems server.
So once we have our development, then we also want to be able to administer and
operate the server that we're working on. So Service Center is the platform
servers' management console and when we think of an admin console we'd
like to be able to see sort of all of our applications how we can monitor them
how we could administer them and some analytics. So the Service Center is an
administration console that you get to through the browser that shows you all
of the information you'd like to know such as "are the different parts
of our current server up and running" so that everything is going well. So Service
Center gives us that type of information. There's a second type of administration
console called Lifetime and this manages the life cycle across different types of
environments. So if we begin to look at some of our apps, whether they be mobile
apps or plugins or other types of information, we can go ahead and look at
our development environment we can then sort of see our QA or integration
environments and there can be multiple environments. We can tag any of our
applications in a particular environment and then move them from one environment
to another by deploying them to the next given server. So Lifetime is a great tool
that allows us to visualize that. It will show us if there are any problems with
applications and if the different versions are having any kinds of
problems, which keeps up the integrity of our server and our applications. So when
we look at all of the components and tools we have our core server, the
OutSystems server, we have Service Studio and Integration Studio for development
tools and Service Center and Lifetime as administration types of tools. Now we
also have a robust community and one part of the OutSystems community is the
OutSystems Forge.
This is a location on the Web where we can go and look for installable
components and/or applications so there are a lot of interesting components and
applications, hundreds of components and applications, so you can come out and
search for different things that are available and by selecting any of them
you can go ahead and download them and bring them into your development
environment, so sometimes you don't have to generate or create something from
scratch, you may be able to start with one of these components or begin getting
ideas from the components that do exist. So the Forge is a great community tool
for us to be able to have resources available at anytime we need them.
There also is the Community Forums and here we can go to exchange different
types of information, give people tips or other types of things, or get our
questions answered as to how we might do things like creating new user apps. So
the Community Forums are a great place to get more information and to check for
all the things that we might need. So given all of those components and tools,
how do they work together or how are they structured? Well if we think of the
logical architecture of an OutSystems server what you'll find is that Lifetime
will be installed as an application, if its installed, Service Center would be an
application as well, and all of the admin consoles or the development tools
will connect. So you can see the Integration Studio and Service Studio
connect to Service Center, Lifetime and Service Center will connect to their
respective apps. When we're doing development we would go ahead and work
to push things to Service Center and then the rest of the structure is there
to kind of allow the whole system to work properly, and part of
all of those things working together would be deploying applications. So
inside of our Service Studio environment, when we have our code ready to go, we
have a 1-Click Publish button and that will send that application's information
to the server and the server then will begin deploying it so it can compile the
code and get it ready to run as an application. Inside of Service Center we
can do the same thing, so if we're in the admin console and we need to be able to
publish one of these applications we can publish it from Service Center just as
we could publish it from Service Studio so we don't have to be in the
development tool to be able to do this. We can do it directly from Service
Center if we need to, but if we're in Service Studio we would publish to
Service Center. Service Center immediately stores the information about
the application in the metadata database. It then takes the description of the
application and begins compiling it into real code, whether that would be Java or .Net
depending on our platform. The Deployment Controller Service would then begin
deploying the application and it would then be available as a Web app. If this
Web application needs data then part of that structure would also be going to
the database whether it's SQL Server, Oracle or whatever database we might be
using, and it will go ahead and get that ready so that it will have the data
available for the Web app. If we're building mobile applications it will also
create the mobile application bundle so that the device would be able to get the
application that it needs. So a lot of different things that are going on
inside of the architecture sort of behind the scenes. So we've tried to give
you a quick overview of what OutSystems 10 is, the main components which are the
server, the studios to do development work, and some of the admin pieces, and we
briefly looked at the architecture and how sort of we step through the
different pieces to deploy applications. So hopefully that gives you a better
feel for what OutSystems 10 is and you'll feel more comfortable as we move
forward.