welcome everyone to another tech versus
here our topic for today what's the best
approach to build the next generation of
applications our contenders on my left
we have low code on my right we have no
code if you take a look at both of these
particular technologies they both
provide an approach to rapid application
development so with that let's give them
both a check mark and we're tied up one
one
second round two let's get to the fact
of what kind of tools they provide
no code on my right is going to give you
a 100 percent
visual ui i'm talking drag and drops
pointing clicks all are included but
on my left we have low code which is
going to give you everything that no
code provides
plus the ability to insert code through
scripting clearly we have another check
mark here
and i'm sorry no code i got to give you
an x there so it looks like low codes in
the lead here but actually i would like
to make a modification to this instead
of it being a low code versus no code i
really think it's time to make it a
low code and no code
so let me explain here
well first i want to point out to let's
deal with one aspect here that we'll
call collaboration
so what do you mean there jamil here
let's take we have three different
personas that are interacting let's say
that we have
professional devs
we have power users
and we have citizen devs
so the fact that we have all this
collaboration available you can leverage
low code
all these different tools that they can
use
to function together and let's say at
the end we are the goal is to build this
application that we want to do our
project
so all these three groups of users can
effectively work together on on a
project
to work together each bringing their own
expertise instead of most applications
where mostly the professional developers
lead everything trying to get input from
other lines of business in there so it
really provides parallel contribution to
the overall project here
next let's take another shift at this we
can also say from a second perspective
we can do this from a
what i would like to call a mix
a mixed tool set here and what do you
mean by that so let's say we have some
components of this application or
project let's say this is the ui which
can be done in a
no code let's say we have participation
from
let's go ahead and make this the laptop
so let's say that this is a low code for
your ide
it may have low code capabilities built
in to what you're using and then we may
have the final piece may be other
services that are built
and they can be a combination of both
low code and no code depending on the
context of how they generate so
effectively why would i want to single
out one or the other when i can combine
the capabilities and really meet in the
middle to have mixed tool set along with
all my users working together
effectively local and no code working
together here and my last point i want
to bring up
is around the next generation
so we uh one thing we aren't talking
about here is there's still
what complements low code and no code is
you may call it manual code i like to
call it custom code that are built so
what if you can take advantages of most
custom code is built to purpose
to kind of everything without local to
no code you're going to be building
everything from scratch to do everything
but let's say that we are leveraging
low code and no code tools to really
provide additional capabilities here
now it gives me a capability for my
professional developers to
actually
adhere to our major principle
all right which is don't repeat yourself
so what if
i can build my next generation of tools
as professional developers to actually
facilitate these functionalities all my
users are already expecting this
capability i can bring in other lines of
business other users to participate but
what if i want to build my custom code
in low code fashion or
no code fashion by just providing a ui
which is already built
to function and
local by maybe still providing some
parameters you can enter in
and really function through that way
another thing i want to bring up too the
reason you want to have this inside your
architecture is because two all these
low code and local toolsets come from
custom code automatically
so you are leveraging
dependable uh
tool sets free of errors as much as it
can be very seasoned code that's meant
to participate and do the same
repeatable action for you
without that as a developer you'll be
professional developer you'll be writing
that code over and over again so there
we have it folks we're going to call
this match an even score they all work
together i love to hear your comments
below and what you think on this topic
and please subscribe to our channel so
we can keep bringing you great versus
battles like this