Low-Code in 30: Deliver High-Quality Apps

• Cloud

• Transcript

  [00:00:04.709]
  Welcome to the latest edition in

  [00:00:06.750]
  locating thirty.

  [00:00:08.509]
  My name is Simon Black. Kind of a technology evangelist

  [00:00:11.169]
  here. Bendix

  [00:00:13.240]
  in today’s located thirty, we’re

  [00:00:15.269]
  gonna be covering delivering high quality

  [00:00:17.429]
  APS throughout the entire application

  [00:00:19.670]
  life cycle.

  [00:00:23.879]
  Over the last few months, we’ve covered a number

  [00:00:26.320]
  ofthe topics in these low code in thirteen,

  [00:00:30.570]
  everything from collaborative visual development

  [00:00:33.060]
  through to comprehensive security.

  [00:00:35.840]
  So if you weren’t able to attend that particular

  [00:00:38.109]
  weapon ours, you can always catch them on

  [00:00:40.229]
  demands are our YouTube channel.

  [00:00:46.240]
  Before we dive into today’s topic,

  [00:00:48.679]
  I want to just give you an overview as to what

  [00:00:52.590]
  Bendix was born to help enterprises bring

  [00:00:54.700]
  with APS.

  [00:00:55.829]
  And it’s the fastest and easiest loco platform

  [00:00:58.509]
  to create mobile and Web applications

  [00:01:00.509]
  at scale.

  [00:01:02.560]
  The way they do this is we have an

  [00:01:04.599]
  entire platform

  [00:01:06.209]
  that takes everything from requirements

  [00:01:08.439]
  covering development, deployment

  [00:01:10.510]
  on operating

  [00:01:11.939]
  on each of those stages. We try

  [00:01:14.019]
  to bring business together

  [00:01:16.459]
  so that they can collaborate around

  [00:01:18.469]
  the development off that project.

  [00:01:21.640]
  By doing so, it enables us to

  [00:01:23.730]
  build applications ten times faster

  [00:01:26.150]
  than traditional development,

  [00:01:27.840]
  unused seventy percent fewer resources.

  [00:01:31.939]
  When developing these applications,

  [00:01:34.840]
  we need to make sure that we’re still

  [00:01:36.849]
  delivering the same level of quality

  [00:01:39.260]
  at a quicker speed.

  [00:01:44.739]
  So for equality is a top priority

  [00:01:46.920]
  for many organizations

  [00:01:49.439]
  approximately seventy percent

  [00:01:51.540]
  of all digital projects of failing

  [00:01:54.140]
  because they’re not meeting the expectations

  [00:01:56.599]
  or the quality levels that

  [00:01:58.609]
  business demands.

  [00:02:02.090]
  These expectations are often defined

  [00:02:04.819]
  in certain requirements,

  [00:02:06.819]
  and usually these split into two

  [00:02:09.219]
  functional requirements on non functional

  [00:02:11.430]
  requirements.

  [00:02:14.120]
  Functional requirements dictate

  [00:02:16.060]
  how well it complies

  [00:02:18.319]
  and conforms to a given design.

  [00:02:20.939]
  You come up with a list of requirements, like

  [00:02:22.969]
  in this ring binder here.

  [00:02:24.719]
  These are often defined by the business

  [00:02:27.129]
  they’re given to the team’s, who

  [00:02:29.180]
  then have to go and deliver it.

  [00:02:31.419]
  But often this does not meet the level

  [00:02:33.629]
  ofthe quality that the business requires,

  [00:02:36.719]
  because often these changing over time,

  [00:02:39.389]
  their expectations of changing business

  [00:02:41.520]
  requirements are changing.

  [00:02:43.120]
  So therefore you need to have a different process

  [00:02:45.439]
  where these requirements are gathered

  [00:02:47.870]
  on their communicated together

  [00:02:51.520]
  on the non functional side.

  [00:02:53.319]
  If we start to deliver applications that

  [00:02:55.740]
  are not scaleable are not performing.

  [00:02:58.189]
  We often result in situations like

  [00:03:00.409]
  this picture here. When we have frustrated

  [00:03:02.840]
  end users,

  [00:03:04.060]
  they’re not able to use our application

  [00:03:06.300]
  the way that they want

  [00:03:12.280]
  to ensure the applications are built.

  [00:03:15.750]
  Meet the business needs.

  [00:03:17.719]
  The minutes platform encompasses several

  [00:03:19.800]
  key tools.

  [00:03:21.520]
  The first one is that we have a development platform

  [00:03:24.210]
  is designed to enable Business ninety

  [00:03:26.500]
  collaboration,

  [00:03:27.819]
  every state of the development process.

  [00:03:31.560]
  The second is that we have a requirements

  [00:03:33.680]
  management tool, allowing to have one

  [00:03:35.879]
  central view of all of the projects

  [00:03:38.340]
  and requirements

  [00:03:39.560]
  and see an updated overview of

  [00:03:41.800]
  the Progress Wass development.

  [00:03:46.219]
  And lastly, we have a central portal

  [00:03:48.490]
  so that we can manage and uses ideas,

  [00:03:51.400]
  issues on bucks.

  [00:03:53.460]
  I’ll be able to give their feedback from

  [00:03:55.599]
  their stakeholders and it rained upon

  [00:03:57.680]
  our application.

  [00:04:03.539]
  Haven’t complete visibility off all those

  [00:04:05.659]
  requirements is important.

  [00:04:07.639]
  But you must make sure that what’s your

  [00:04:09.789]
  building those requirements.

  [00:04:11.840]
  You’re consistently meeting those needs

  [00:04:14.169]
  and you’re not breaking things in the process.

  [00:04:17.189]
  This is where testing is important.

  [00:04:19.819]
  Bendix platform treats testing no different

  [00:04:22.269]
  to any other development platform.

  [00:04:24.540]
  Recover all types of testing.

  [00:04:27.240]
  But three key areas would like to highlight

  [00:04:29.459]
  today. The first

  [00:04:31.550]
  one is functional testing,

  [00:04:33.439]
  insuring what we build meets

  [00:04:35.779]
  the end users expectations.

  [00:04:38.129]
  And this is usually performed using our application

  [00:04:40.509]
  test suite.

  [00:04:41.980]
  I’ll demonstrate this later in my demo.

  [00:04:45.639]
  Second, we need to have a facility

  [00:04:48.389]
  for unit testing.

  [00:04:50.040]
  This is done using the J Unit module

  [00:04:52.819]
  on the unit testing module from our APP store.

  [00:04:56.740]
  Finally, we need tohave integration

  [00:04:58.990]
  testing,

  [00:04:59.939]
  So we need to be able to test the dependencies

  [00:05:02.220]
  between our different micro services

  [00:05:04.350]
  or different applications.

  [00:05:06.139]
  And usually we do this using soap

  [00:05:14.939]
  when we’re developing in speed,

  [00:05:17.319]
  it’s important that those applications

  [00:05:20.230]
  are built to be maintainable over

  [00:05:22.310]
  time. The platform

  [00:05:24.660]
  is designed to ensure that whatever

  [00:05:27.060]
  you build is maintainable of

  [00:05:29.290]
  perform herbal,

  [00:05:31.740]
  not leaving you with the technical debt

  [00:05:33.949]
  over the years.

  [00:05:36.639]
  We do this on several levels,

  [00:05:39.339]
  but I’ve highlighted three here today.

  [00:05:42.189]
  The first one is the

  [00:05:44.639]
  A current will perform static analysis

  [00:05:46.860]
  of your application models

  [00:05:48.660]
  and tells you how maintainable is

  [00:05:51.019]
  where you need to make changes.

  [00:05:53.800]
  This is part of my demo. Later,

  [00:05:56.519]
  I’ll show you how we can utilize

  [00:05:58.589]
  that tool to be able to improve

  [00:06:00.973]
  our applications, maintain ability.

  [00:06:06.072]
  When we were building our application. The

  [00:06:08.362]
  model is consistently checking it for

  [00:06:10.562]
  errors

  [00:06:11.642]
  usually checked ten to twenty times

  [00:06:14.202]
  more consistently checks compared

  [00:06:16.463]
  to traditional programming platforms.

  [00:06:19.052]
  And this is so that we can ensure that when we run the

  [00:06:21.103]
  application, it will run correct

  [00:06:23.543]
  first time

  [00:06:26.052]
  and finally throughout the platform,

  [00:06:28.372]
  we haven’t a I assisted development.

  [00:06:31.372]
  This enables us to give suggestions

  [00:06:34.033]
  as to best next steps

  [00:06:35.892]
  based on industry standards

  [00:06:37.872]
  so that we can improve the quality as

  [00:06:40.033]
  we’re going through our development.

  [00:06:46.872]
  In order to guarantee the applications

  [00:06:49.223]
  are maintain away. The time

  [00:06:51.033]
  is also important. That we re

  [00:06:53.283]
  use thes components

  [00:06:55.862]
  we use is an essential part ofthe

  [00:06:57.983]
  software development.

  [00:07:00.862]
  Almond ex applications are built using model

  [00:07:03.213]
  driven development.

  [00:07:04.642]
  This ensures that we can reuse any

  [00:07:07.142]
  part off the platform on any part

  [00:07:09.322]
  of the APP

  [00:07:10.543]
  against other applications.

  [00:07:13.872]
  The way we usually reuse thes module

  [00:07:16.083]
  components

  [00:07:17.233]
  is by uploading those into our APP

  [00:07:19.353]
  store. The APP store

  [00:07:21.382]
  comes in two flavors. A private APP

  [00:07:23.523]
  store only available for your

  [00:07:25.622]
  price

  [00:07:26.673]
  on a public APP store. This available to

  [00:07:28.802]
  the whole community.

  [00:07:30.773]
  The story’s a component library, which

  [00:07:32.942]
  really accelerates that application developed.

  [00:07:37.262]
  Finally,

  [00:07:38.372]
  in order to have true reuse,

  [00:07:40.942]
  you need to be able to break up your app into

  [00:07:43.302]
  a set of single mike services

  [00:07:46.372]
  to being out to orchestrate those being

  [00:07:48.523]
  out to build those

  [00:07:50.142]
  out, to reuse those different logic

  [00:07:52.562]
  in multiple aps

  [00:07:58.442]
  for my demonstration today

  [00:08:00.492]
  that you’re going to use a scenario that we’ve

  [00:08:02.579]
  used in three previous weapon ours.

  [00:08:05.509]
  This scenario is around on

  [00:08:07.560]
  inspections up.

  [00:08:08.930]
  An inspector is on a particular container

  [00:08:11.189]
  ship he might have received on

  [00:08:13.329]
  a on his mobile device

  [00:08:15.689]
  That something has happened to a particular container

  [00:08:18.000]
  on the ship.

  [00:08:19.029]
  He needs to go and inspect it

  [00:08:20.779]
  and then see what is wrong.

  [00:08:23.040]
  Records and information on his mobile device.

  [00:08:27.230]
  This demonstration. We’ve got a showcase.

  [00:08:29.420]
  Quickly, the application.

  [00:08:31.329]
  We’re gonna submit a feedback,

  [00:08:33.769]
  see how we can manage that feedback

  [00:08:36.190]
  and see how we can add. Then use

  [00:08:38.470]
  use attests to that particular use

  [00:08:40.600]
  a story and finally,

  [00:08:42.889]
  would then see how you could leverage

  [00:08:46.129]
  so that we can see how well our

  [00:08:48.149]
  application is in terms of maintain ability.

  [00:08:51.779]
  Now that we’ve seen how the medics

  [00:08:53.879]
  platform addresses quality,

  [00:08:55.830]
  let’s take a look at two of those particular

  [00:08:58.019]
  platforms in more detail.

  [00:09:00.490]
  Thie platform on

  [00:09:02.490]
  the platform. A leverage. This

  [00:09:04.570]
  particular demo application

  [00:09:11.230]
  So I have the open in my browser

  [00:09:13.399]
  here, and we can in this particular

  [00:09:15.620]
  avocation, CIA number ofthe inspections

  [00:09:18.120]
  that we need to do on a particular container

  [00:09:20.450]
  ship. We can see the task

  [00:09:22.539]
  for each of those inspections on. As

  [00:09:24.590]
  we drill down, we can see each

  [00:09:26.659]
  individual question. We need to answer

  [00:09:28.769]
  when we do this particular inspection

  [00:09:31.129]
  for each of the questions, we can upload photos

  [00:09:33.659]
  we cannot notes

  [00:09:35.070]
  and be able to get a complete overview as to

  [00:09:37.139]
  what we need to complete for this particular

  [00:09:39.389]
  task.

  [00:09:42.129]
  Now, when you’re developing an application, often you need

  [00:09:44.259]
  to capture ideas, questions

  [00:09:46.570]
  and issues from your end, uses

  [00:09:48.700]
  your developers or testers.

  [00:09:51.039]
  And to do that minutes has a booting

  [00:09:53.340]
  feedback mechanism

  [00:09:55.200]
  on the right side. Here we have this feedback button

  [00:09:57.610]
  when we press it, it brings us into the

  [00:09:59.649]
  feedback mode.

  [00:10:01.049]
  And once we’re in the feed back road, we can select

  [00:10:03.110]
  anywhere on the screen that we would like.

  [00:10:05.381]
  Our new particular feature or issue

  [00:10:07.642]
  has occurred,

  [00:10:08.912]
  and this pool automatically take a screenshot

  [00:10:11.331]
  off where the user was at the time

  [00:10:13.861]
  and also identified there where

  [00:10:16.182]
  they were clicking as well.

  [00:10:18.812]
  We can then add a comment to this particular

  [00:10:21.172]
  feedback item so that the

  [00:10:23.322]
  Jews of the tester on developers

  [00:10:25.491]
  no, exactly what needs to be added

  [00:10:27.922]
  to satisfied my particular demands.

  [00:10:31.562]
  I’m not gonna go through that process today, but

  [00:10:33.892]
  earlier weaponized feature this particular

  [00:10:35.932]
  scenario.

  [00:10:38.412]
  So all of that feedback will go into our

  [00:10:40.481]
  project management portal.

  [00:10:42.251]
  And this is really where we can gather

  [00:10:44.442]
  those requirements. Collaborate

  [00:10:46.491]
  arounds, thie, initial user stories, and

  [00:10:48.822]
  we can also manage out our feedback as well.

  [00:10:51.611]
  So all of the feedback that users submit

  [00:10:54.381]
  goes into this central portal here

  [00:10:56.511]
  we can manage the open feedback, the

  [00:10:58.601]
  handled and also accepted feedback,

  [00:11:01.461]
  and we can then tie those back into

  [00:11:03.721]
  individual users stories.

  [00:11:05.611]
  So when we accept a feedback item, this

  [00:11:07.711]
  will go into our story section

  [00:11:10.052]
  and creates a new requirement which

  [00:11:12.172]
  we can then start test cases, too,

  [00:11:14.902]
  in our

  [00:11:16.072]
  platform,

  [00:11:17.851]
  so we can see here we have a user story as a

  [00:11:19.851]
  user would like to be out to get conditional

  [00:11:21.881]
  questions based on your response.

  [00:11:24.412]
  So in order to make sure that we are meeting that

  [00:11:26.581]
  requirement consistently, as we

  [00:11:28.682]
  add new features, we need to be able to

  [00:11:30.741]
  add a test script for this,

  [00:11:33.412]
  and to do so we need to jump into

  [00:11:35.501]
  the platform.

  [00:11:39.971]
  This is a browser based platform and

  [00:11:42.011]
  allows it to see across all of our applications

  [00:11:45.001]
  which test cases have passed

  [00:11:47.341]
  on which have failed over the last

  [00:11:49.412]
  seven days. So this gives us a high level

  [00:11:51.652]
  view as to the progress of our

  [00:11:53.792]
  applications.

  [00:11:55.652]
  See, here are loco mobile experiences

  [00:11:58.642]
  application

  [00:11:59.792]
  and when we drew down on this, we can see some more

  [00:12:01.871]
  in depth information about the test

  [00:12:04.172]
  cases. And over the last seven days, we

  [00:12:06.246]
  can see this graft to see how we’re progressing.

  [00:12:11.917]
  On the test cases section here. This is really

  [00:12:13.976]
  where we can see each of the test cases

  [00:12:16.417]
  or the test sweets that we’ve

  [00:12:18.567]
  recorded in this particular technology.

  [00:12:23.187]
  We can also see certain test data

  [00:12:25.716]
  so we can upload that test data

  [00:12:28.067]
  in C S V in Excel.

  [00:12:30.437]
  And this allows us to run on a

  [00:12:32.756]
  bulk upload bulk process

  [00:12:35.407]
  a number of tests in this particular

  [00:12:37.486]
  script.

  [00:12:39.616]
  So we might want to test on a thousand

  [00:12:41.716]
  users, for instance,

  [00:12:43.116]
  and upload them and register them into the

  [00:12:45.157]
  platform. We can do this by the test

  [00:12:47.407]
  data scripts.

  [00:12:49.687]
  And finally, we have a direct link

  [00:12:52.006]
  into those stories that we showed

  [00:12:54.167]
  in the development platform

  [00:12:56.317]
  so we can add certain test cases

  [00:12:58.976]
  to those new features that we’ve

  [00:13:00.996]
  developed.

  [00:13:03.777]
  So we’re going to take the last test case here. The

  [00:13:05.927]
  last user story here on added new

  [00:13:07.956]
  test case.

  [00:13:09.317]
  When we do so, this sidebar will come

  [00:13:11.537]
  up here, and this is where we can select

  [00:13:13.767]
  existing test cases or

  [00:13:15.826]
  test sweets on link those two individual

  [00:13:18.366]
  use stories.

  [00:13:20.586]
  In our case, we’re going to create a new test case.

  [00:13:23.616]
  We’re going to give it a name off answering

  [00:13:26.466]
  questions,

  [00:13:29.537]
  select a number ofthe templates.

  [00:13:32.586]
  So a template is essentially a

  [00:13:35.267]
  baseline of what we want.

  [00:13:37.647]
  This particular test case to include

  [00:13:40.297]
  so include a number ofthe steps as

  [00:13:42.626]
  default

  [00:13:44.787]
  and help with this particular flow. We

  [00:13:46.797]
  already created some of these as a template,

  [00:13:49.667]
  so we’re going to open up the particular task.

  [00:13:52.157]
  We’re gonna open up a particular question,

  [00:13:54.547]
  and then this gives us the ability to then

  [00:13:56.777]
  add our additional steps.

  [00:13:59.917]
  If I hit, create an open, it will take

  [00:14:02.297]
  that particular example test

  [00:14:04.657]
  template and create those individual

  [00:14:06.884]
  steps for us.

  [00:14:08.624]
  So we see here on the test steps, we could drill

  [00:14:10.774]
  down on each of those and see some more

  [00:14:13.014]
  in depth information,

  [00:14:14.624]
  so for each type off, activity

  [00:14:16.764]
  will have a number off different properties

  [00:14:18.793]
  here. This one, We’re cooking a

  [00:14:20.793]
  button, so we need to know the witch it

  [00:14:22.793]
  name that we need to click

  [00:14:24.484]
  and in minutes every property, every

  [00:14:26.653]
  container, every button

  [00:14:28.433]
  contains his own unique which it name,

  [00:14:31.173]
  and this allows us to identify it when we

  [00:14:33.244]
  performed the script.

  [00:14:38.583]
  We also have the test data as well as we can

  [00:14:40.624]
  mark back which particular test data

  [00:14:42.813]
  we want to use for this particular test

  [00:14:45.024]
  case, we can see the usages

  [00:14:47.153]
  of where it’s being used.

  [00:14:48.974]
  Finally, we can see those stories that have been links.

  [00:14:51.293]
  We combine multiple stories for a

  [00:14:53.333]
  particular test case.

  [00:14:57.384]
  Now, when we’re defining thes individual

  [00:14:59.394]
  steps, we can even decide to record

  [00:15:01.663]
  them manually.

  [00:15:02.913]
  And when we do so, we’re asked to select

  [00:15:04.984]
  from a particular function or in action.

  [00:15:07.514]
  There’s a number ofthe default actions in here

  [00:15:10.004]
  that have been built to support the

  [00:15:12.063]
  Mendez platform.

  [00:15:13.573]
  So things like clicking on certain buttons,

  [00:15:15.884]
  selecting certain CSS elements

  [00:15:18.384]
  all could be configured and added into

  [00:15:20.634]
  this app.

  [00:15:23.024]
  But we also have the option to record

  [00:15:25.244]
  these. So if we want to use the browser

  [00:15:27.653]
  recording so

  [00:15:29.004]
  we could simply select record step,

  [00:15:31.793]
  what this does is now sets up a recording

  [00:15:33.833]
  session for us so that we can

  [00:15:36.043]
  in the browser click on certain items

  [00:15:38.203]
  and it will create those individual steps for us.

  [00:15:41.803]
  I’m gonna head over to that tool. Now we can see

  [00:15:44.014]
  that we have the feedback item open from

  [00:15:46.203]
  before close that down now

  [00:15:48.524]
  started. Add certain tests.

  [00:15:51.423]
  So when we click the options here,

  [00:15:53.583]
  every record that I’ve selected certain items

  [00:15:56.433]
  record I’ve selected No. And then yes,

  [00:15:59.293]
  it will record when I enter in a

  [00:16:01.524]
  date, for instance,

  [00:16:02.974]
  and also record information like when

  [00:16:05.063]
  I type in the condition ofthe

  [00:16:07.096]
  the container.

  [00:16:10.876]
  Hop over back over to the

  [00:16:13.397]
  platform

  [00:16:14.346]
  we can see here. It’s set.

  [00:16:16.417]
  The item as good

  [00:16:18.136]
  is answered. Certain items as

  [00:16:20.177]
  No

  [00:16:21.017]
  for our first question, is then

  [00:16:23.037]
  answered no to the second question and

  [00:16:25.267]
  then changed his mind. Tea? Yes, for instance,

  [00:16:28.657]
  on the right hand side here you can see

  [00:16:30.986]
  what the values are being set on, what

  [00:16:33.096]
  the assertion value should be.

  [00:16:35.157]
  It’s the session value is saying, What

  [00:16:37.417]
  should that value be when

  [00:16:39.417]
  we enter this information?

  [00:16:41.876]
  It’s a really good way of comparing and making

  [00:16:43.937]
  sure that when we select, the certain item

  [00:16:46.456]
  is meeting those values that

  [00:16:48.527]
  we we think it should.

  [00:16:51.057]
  The witch it name here allows his store identify

  [00:16:53.086]
  what we want to select allows

  [00:16:55.126]
  us to make sure that that run

  [00:16:57.856]
  when we hit safe. What This would do it and create

  [00:16:59.947]
  those individual steps. Here. We see these

  [00:17:02.057]
  now in here.

  [00:17:03.057]
  We contract and drop these in the browser so

  [00:17:05.237]
  that we can move the order around.

  [00:17:07.517]
  So we want to be out two slept these answers before

  [00:17:10.297]
  we actually hit the complete button

  [00:17:14.356]
  So now we’ve added some additional steps. We

  [00:17:16.487]
  want to be able to run this, and we want to be out to

  [00:17:18.527]
  test it on a number of different browses

  [00:17:21.207]
  on also a number of different environments.

  [00:17:25.146]
  In our case, we’re going to select our acceptance

  [00:17:27.317]
  environment,

  [00:17:28.237]
  and we’re going to run this on a selenium, huh?

  [00:17:30.957]
  So under the hood,

  [00:17:32.356]
  the eighty s platform is creating

  [00:17:34.626]
  a number ofthe selenium scripts.

  [00:17:36.817]
  And selenium is a way of creating automated

  [00:17:39.217]
  tests in the browser or

  [00:17:41.267]
  on the device.

  [00:17:42.757]
  And this is a selenium hub is

  [00:17:44.916]
  a place where you can run. There’s selenium scripts.

  [00:17:47.757]
  In our case, we’re going to use browser stack.

  [00:17:49.856]
  You can also use source lamps all your own

  [00:17:52.126]
  selenium. Heart of your choice.

  [00:17:55.257]
  We’re also going to select the browser Chrome.

  [00:17:57.596]
  I’m running on a Windows ten machine

  [00:18:01.356]
  when I hit run. Now, once this will do,

  [00:18:03.567]
  also take those scripts that we’ve

  [00:18:06.023]
  could find in our

  [00:18:08.114]
  platform. Send those to

  [00:18:10.173]
  the browser hub Selenium stack

  [00:18:12.624]
  on will allow us to then

  [00:18:14.513]
  test phase in the process

  [00:18:18.294]
  if I go get a browser stack now I can see

  [00:18:20.884]
  that there is a test now starting to start

  [00:18:23.034]
  up. That could have been triggered

  [00:18:25.473]
  even manually

  [00:18:26.743]
  or via assists.

  [00:18:28.263]
  Pipeline.

  [00:18:29.453]
  The platform has the ability to connect

  [00:18:31.753]
  into any platform such as Jenkins.

  [00:18:34.284]
  Vsd s allow you to trigger

  [00:18:36.374]
  these over on a new build

  [00:18:38.614]
  on a new commit and run

  [00:18:40.743]
  thes in the browser.

  [00:18:43.433]
  Do you see here it runs each of the steps

  [00:18:45.483]
  so starts the browser opens up particularly

  [00:18:47.753]
  Eurail. It waits for the application

  [00:18:50.003]
  to be ready, and then we’ll perform each of

  [00:18:52.054]
  those steps.

  [00:18:53.763]
  Now, once is complete, it will actually

  [00:18:56.034]
  record that particular session for us.

  [00:18:58.564]
  So we can view each of those steps in

  [00:19:01.314]
  the video recording here.

  [00:19:03.364]
  So we can see, for instance, festival. It will go

  [00:19:05.523]
  to the euro.

  [00:19:07.064]
  It will then form a log in to

  [00:19:09.233]
  the application

  [00:19:12.963]
  it will finally

  [00:19:14.953]
  open up the page that we want Teo

  [00:19:17.374]
  to use. So

  [00:19:24.233]
  it’s going to select the particular container.

  [00:19:27.864]
  It will then answer. A number of these questions

  [00:19:30.673]
  have. Finally, it will hit the complete

  [00:19:32.844]
  button so you can see it’s selected good now

  [00:19:35.213]
  on. Then it will close down the browser.

  [00:19:38.364]
  If we go back into the

  [00:19:40.513]
  platform,

  [00:19:41.564]
  we will see that it’s past the actual

  [00:19:43.584]
  overall test,

  [00:19:44.963]
  and we can also see a number of tests

  [00:19:47.144]
  that have failed.

  [00:19:48.663]
  If any point that particular test fails,

  [00:19:51.294]
  it will record it what step it failed

  [00:19:53.644]
  and also record and air a log as to

  [00:19:55.683]
  why it failed.

  [00:19:57.013]
  And finally, a screenshot of

  [00:19:59.074]
  at what point in that particular

  [00:20:01.153]
  process, it failed during the journey.

  [00:20:05.364]
  And also you can see the recording embedded

  [00:20:08.203]
  into the platform here

  [00:20:10.384]
  so we can look run this. We see

  [00:20:12.513]
  why that particular step failed

  [00:20:14.753]
  in the journey.

  [00:20:22.784]
  So we’ve seen how we can leverage thie

  [00:20:25.463]
  application test way to be able

  [00:20:27.483]
  to record functional tests and

  [00:20:29.634]
  ensure that the requirements that

  [00:20:31.673]
  the end uses build in the form of users. Stories

  [00:20:34.453]
  are met using these particular test

  [00:20:36.604]
  scripts. Obviously,

  [00:20:39.844]
  testing is a really poor in part

  [00:20:41.874]
  off the platform. But in order to

  [00:20:43.903]
  be over to add new features

  [00:20:46.094]
  on B over to scale your application

  [00:20:48.294]
  over time, you need to make sure that

  [00:20:50.344]
  you are handing maintain

  [00:20:52.534]
  ability

  [00:20:53.473]
  and that the quality of your application

  [00:20:55.993]
  is overall. Going

  [00:20:58.144]
  to be easy enough so that you can add

  [00:21:00.354]
  new features on DH add

  [00:21:02.584]
  re factoring over time,

  [00:21:05.554]
  and to do that, we use the

  [00:21:07.824]
  rental. So this is the application

  [00:21:09.844]
  quality monitor,

  [00:21:11.534]
  and this does static analysis

  [00:21:13.544]
  off your application models so

  [00:21:15.624]
  it checks it for how well built

  [00:21:17.854]
  Overall you’re you are maintaining

  [00:21:20.284]
  your application

  [00:21:21.364]
  on it will give it a five star rating

  [00:21:23.784]
  based on Isis Standard.

  [00:21:25.983]
  It would check for things like volume, duplication,

  [00:21:29.094]
  unit size unit complexity and

  [00:21:31.213]
  give each of these a five star rating

  [00:21:33.644]
  and then give you an overall rating. Is the hell

  [00:21:35.673]
  well built your application is.

  [00:21:37.884]
  You should always try to aim for a four star

  [00:21:40.003]
  rating. This enables you to have

  [00:21:42.473]
  loose coupling and labels you to

  [00:21:44.503]
  add new features over time much

  [00:21:46.673]
  easier than it would be if it was a three

  [00:21:48.923]
  star or a two star maintain ability.

  [00:21:53.483]
  On the right. Inside here, you can see a maintain

  [00:21:55.614]
  ability trends. So every day

  [00:21:57.854]
  it will check your application using

  [00:22:00.453]
  the Mende ex model s decay so it’ll

  [00:22:02.523]
  connect using the

  [00:22:04.094]
  stick, pull all the information about

  [00:22:06.344]
  your application model.

  [00:22:07.827]
  It will convert it into a pseudo coat,

  [00:22:10.667]
  and then it will compare it against thousands

  [00:22:12.907]
  of applications built in different

  [00:22:15.178]
  technology types. So it might be

  [00:22:17.188]
  in pi thin. It might be in Ruby, it

  [00:22:19.278]
  might be in PHP

  [00:22:21.428]
  and it will give you an overall rating

  [00:22:23.458]
  based on those thousands of applications.

  [00:22:27.347]
  And we could see over time how we’re improving

  [00:22:29.617]
  in those individual components, whether it be

  [00:22:31.698]
  maintain ability, volume, duplication

  [00:22:33.758]
  and so on. We

  [00:22:36.327]
  can see down here how we’re actually

  [00:22:38.678]
  improving or no improving

  [00:22:41.347]
  compared to the last change we made.

  [00:22:43.637]
  So we see here. We’ve made some improvements in

  [00:22:45.768]
  terms of our defecation, but we’ve made

  [00:22:48.087]
  some units size

  [00:22:50.008]
  decreases.

  [00:22:52.228]
  So as we’re going through, we consistently make

  [00:22:54.518]
  an improve

  [00:22:55.428]
  this application.

  [00:22:57.127]
  It also gives us a good idea as

  [00:22:59.288]
  to how well our developers of in

  [00:23:01.357]
  organization are developing.

  [00:23:03.448]
  Are they using the best standards and best

  [00:23:05.498]
  practices in terms ofthe

  [00:23:07.228]
  building and using snippets and reusable

  [00:23:09.647]
  components, or are they building

  [00:23:11.768]
  a mess that’s going to be difficult to

  [00:23:13.827]
  maintain going forward?

  [00:23:18.407]
  The maintain ability dashboard gives us information

  [00:23:21.317]
  as to the makeup

  [00:23:23.317]
  off our application.

  [00:23:24.867]
  So what type of technology are

  [00:23:26.988]
  we using? We get more points if we’re using

  [00:23:29.298]
  more mend its compared Teo using

  [00:23:31.298]
  Java or HTML song.

  [00:23:33.827]
  He also gives us information like a duplication

  [00:23:36.607]
  in its size and gives these in information

  [00:23:39.627]
  easy to use graphs.

  [00:23:42.807]
  The trend section lets you see over time

  [00:23:45.498]
  and compare certain snapshots to see

  [00:23:47.748]
  how well we’re improving.

  [00:23:49.428]
  So we compare, For instance, last year

  [00:23:51.498]
  to this year and see overall,

  [00:23:54.008]
  Are we improving or are we

  [00:23:56.048]
  getting worse?

  [00:23:57.928]
  This gives us a really good idea. As

  [00:24:00.278]
  Teo overall, are

  [00:24:02.278]
  we consistently making sure that

  [00:24:04.288]
  our APP is maintainable on? The quality

  [00:24:06.758]
  of it is is good.

  [00:24:11.472]
  The metrics table allows us to look

  [00:24:13.532]
  at our application from the top

  [00:24:15.742]
  down, so allows us to see

  [00:24:18.022]
  information about, for instance, from

  [00:24:20.153]
  a system level. How many

  [00:24:22.153]
  lines of code

  [00:24:23.542]
  are we developing?

  [00:24:25.313]
  These lines of code, as I mentioned, are based on Suda

  [00:24:27.623]
  Coates. There’s no actual physical code,

  [00:24:30.673]
  but it also gives us a good idea

  [00:24:32.913]
  as to how many man months it would

  [00:24:34.992]
  take to rebuild this particular application.

  [00:24:38.373]
  So it’s based on all of these applications.

  [00:24:40.813]
  They’ve taken from different technologies,

  [00:24:43.093]
  and they’ve come to a baseline as to how long it

  [00:24:45.093]
  would take to rebuild it.

  [00:24:46.972]
  Now these moments are different. If you’re building

  [00:24:49.282]
  in men Nick’s, because we are ten times

  [00:24:51.313]
  faster than a traditional technology.

  [00:24:55.673]
  When you drew down on an application

  [00:24:58.303]
  you can see for each of the modules

  [00:25:00.462]
  and sections were in your application, how

  [00:25:02.692]
  that breaks down

  [00:25:04.022]
  the handyman months. Would it be for each

  [00:25:06.083]
  of those modules? How many comments,

  [00:25:08.202]
  how many lines of code and how many elements

  [00:25:10.633]
  you have within

  [00:25:13.772]
  when we true down fervor in each of these

  [00:25:15.923]
  modules,

  [00:25:16.972]
  we can see the

  [00:25:18.833]
  essentially the pseudo code. But behind

  [00:25:21.853]
  each of those pages, Mike

  [00:25:23.863]
  Flows or these entities.

  [00:25:26.373]
  This is how men it’s built out its applications

  [00:25:28.772]
  that uses these visual models to

  [00:25:30.932]
  build out your maps.

  [00:25:32.593]
  And this is a visual representation

  [00:25:34.813]
  here in the suit, coat off a particular

  [00:25:37.182]
  mike flow,

  [00:25:38.173]
  so we can see it has an activity which is creating

  [00:25:40.512]
  a variable importing and XML

  [00:25:43.002]
  creating a

  [00:25:44.762]
  import mapping.

  [00:25:47.373]
  What it will do is use this so that you can compare

  [00:25:49.853]
  it against other Mike Flows or

  [00:25:51.992]
  other pages or other applications.

  [00:25:57.153]
  The change snapshot section allows you to compare

  [00:25:59.653]
  snapshots from today to yesterday and

  [00:26:01.673]
  so on. The violations

  [00:26:03.752]
  tap here allows us to see what have

  [00:26:06.002]
  we been down marked off.

  [00:26:07.792]
  So why are we not getting that five star

  [00:26:09.803]
  rating? And what can we do to

  [00:26:11.803]
  improve that?

  [00:26:13.593]
  So here we can see we have some

  [00:26:15.843]
  units size violations. So this

  [00:26:17.923]
  might be because we have too many

  [00:26:19.942]
  items on a page. It could be that

  [00:26:22.012]
  we have an entity with lots and

  [00:26:24.012]
  lots of attributes. So that’s not good

  [00:26:26.133]
  practice to do. We should always break those

  [00:26:28.133]
  up. It will show us duplications.

  [00:26:31.073]
  So where On certain pages on

  [00:26:33.123]
  Mike Flows, we have applications

  [00:26:35.452]
  and also it will give us violations

  [00:26:37.512]
  if we have bad coupling.

  [00:26:39.353]
  So if we have modules that are

  [00:26:41.432]
  not loosely coupled, it

  [00:26:43.502]
  will be a ll give us negative

  [00:26:45.813]
  marks and allow us to then

  [00:26:47.942]
  improve those over time.

  [00:26:50.042]
  But it not only does men next models, it

  [00:26:52.093]
  will also look your CSS you’re html

  [00:26:55.032]
  java JavaScript if you’ve added

  [00:26:57.432]
  into the module.

  [00:26:59.542]
  So here we can see we have some java, which

  [00:27:01.952]
  actually is fairly identical.

  [00:27:04.272]
  There’s several sections in here that

  [00:27:06.383]
  we should actually look

  [00:27:08.573]
  to re factor in the process.

  [00:27:13.542]
  Funny, the last section. I want to showcase

  [00:27:16.343]
  his thie dependency graphs

  [00:27:18.942]
  so the dependency grafts looks out.

  [00:27:21.093]
  Your application is a hole

  [00:27:22.843]
  on each of those modules and how

  [00:27:25.113]
  those a couple together.

  [00:27:27.143]
  So you notice there’s a number of lines in between

  [00:27:29.442]
  these and for each of

  [00:27:31.462]
  theme modules. It will check whether

  [00:27:33.803]
  those dependencies on those

  [00:27:35.942]
  couples couplings between those modules

  [00:27:38.373]
  are good or bad.

  [00:27:40.103]
  So here we can see we’ve got some bad coupling

  [00:27:42.492]
  because it’s using certain

  [00:27:44.782]
  activities modules,

  [00:27:47.163]
  and it’s not using those

  [00:27:48.863]
  in a reusable way.

  [00:27:50.942]
  That’s why it’s highlighted in red,

  [00:27:52.853]
  and we can then start to go in and fix those.

  [00:27:57.042]
  So has mentioned all of this. Information

  [00:27:59.482]
  that is getting about these application

  [00:28:01.762]
  models is provided by the model

  [00:28:04.163]
  s decay

  [00:28:05.542]
  on the model. S Decay is something that we

  [00:28:07.553]
  will feature in our next weapon on which

  [00:28:09.553]
  will be about open, extensive bility.

  [00:28:11.803]
  It’s a powerful feature of the platform

  [00:28:14.492]
  that allows you to do several things

  [00:28:16.692]
  with it allows you to import, to

  [00:28:18.972]
  export, but also do analysis

  [00:28:21.182]
  off those models.

  [00:28:26.222]
  So hopefully in the last twenty minutes or

  [00:28:28.282]
  so off this demo, I’ve been out. Which should

  [00:28:30.373]
  demonstrate to you some of the capabilities

  [00:28:33.333]
  that make up the men, Dex software quality.

  [00:28:36.153]
  And we’ve been able to demonstrate, in

  [00:28:38.242]
  particular the eighty s platform

  [00:28:40.553]
  on the platform.

  [00:28:44.923]
  So I hope you have enjoyed this low

  [00:28:47.143]
  coat Webinar

  [00:28:49.123]
  with