So, just to reiterate this slide in case some people didn't hear me
we talked about evolution from functional languages to structural languages to object-oriented languages
During object-oriented languages, the client server was big. You could sit in front of one tool and you can build your whole application
Now, in the early 90s or the mid-90s, the web really took off
So, languages like HTML, CSS, JavaScript, though they existed before, really took off because commercial applications started being built using these products to have a presence on the web
All of a sudden, what happened was you now needed to know five languages to really build a well-designed application
So, you needed HTML, CSS, and JavaScript for the UI. You still needed languages like Java, C Sharp in the back end
And then, obviously, the database language, which if you talk about relational, is SQL
So, now, productivity had to actually morph. Now, instead of having one language in your arsenal, you now have to hire five different skill sets to basically build an application
and deploy them in different servers, if you will, if needed, for sake of security and stuff like that
During this time, I actually ended up building a company called Admin Server, which in the first decade of 2000 got acquired by Oracle
But, during that time, about the time we were being acquired, we saw a little fork in the software development world
Because human beings always look for productivity, how can I get the same effect by doing it much faster
Unconsciously or consciously, all human beings think that way. So, a whole bunch of people said, hey, we're already using the scripting language to, for example, JavaScript, to do the UI
Why don't we morph that into even doing the business logic? So, that way you can cut out one language like maybe Java or C Sharp out of the picture
and you can build a whole stack just with a small subset of languages, hence increasing productivity
This gave rise to a lot of the scripting languages becoming really, really popular
I mean, before that, Perl was the biggest scripting language. It was used to put together little utilities
But now people really started using these scripting languages to build actual, complex, mission-critical applications, which we call server-side scripting
Whereas a certain number of companies continued in their traditional design patterns
where you use compiled languages for the back end, where you keep your business IP, your intellectual property
and then you use your front end purely just to display stuff, so in case that the scripting languages get hacked
you're not at any danger of losing your intellectual property. The problem with scripting languages, while they give you increased productivity
where a new person can come in, learn these scripting languages quickly
not only that, they can simply go somewhere and download a library and then just move on building these applications
quote unquote, quickly, there were a lot of risks. Obvious risks are security, and all these languages, almost all these languages, are immature
If you take JavaScript, for instance, there is no type-driven capability in JavaScript
A variable can be used as a string, integer, whatnot, invariably, all over the place
And then they're not compiled, so there are scalability concerns there. Now, people started mitigating these risks
Anytime a risk arises, people try to bring up solutions. Well, to control the security aspect of these scripting languages
they started spending billions of dollars on cybersecurity, so that became a big, quote unquote, trending buzzword in the industry for a while
Then, obviously, since these languages are immature, they couldn't build monolith applications anymore
so what did they do? They said, oh, we're going to split everything up into smaller pieces
and so the concept of microservices came into play. Of course, they forgot about the fact that doing transactional stuff across these services
is going to become even more complex and stuff like that, and again, deploying 1,000 microservices over one monolith became a huge issue
so the concept of DevOps came into the picture to solve that
And again, with respect to that specific issue that I talked about
type-driven, for example, what they did was they started putting abstract things
like VAS and Angular and jQuery, EXTJS, if you will, 10 years ago
So they started putting in these layers above the same language, trying to make it better and better, thus increasing more technologies that you have to learn
Now, this became great for developers because their resumes started caching up
a bunch of the new quote-unquote cool things, but in the end, the value for the person spending the money starts degrading
And again, the scalability was handled by hardware, and the advent of cloud really was that
We decided to, we saw this issue coming up in the late 2000s
and we decided, okay, time for us to build something that keeps all the good principles
but still have this one tool that generates all of those technologies
Not only that, as technologies change, make this product generate that new technology
so it will never be one of those tools where, when technology radically changes
it becomes useful. So in the end, we just built a platform which is one tool
and it builds all the full stack, and we decided, we found that we can develop 10 times faster with about 70% savings
and we found that in every single product. We'll come back to the platform later
So this is kind of like what happens these days, right? You go to any large company, every developer or senior architect they hire
they bring in whatever they're familiar with, and they see the advantages to what they know, and they bring it in
And it's a major mix-up of a lot of things. And again, in the beginning it looks very good
and then over time what happens is, it becomes a big mixture
and then it becomes a maintenance nightmare. What happens with Graphile is that you have one tool that generates the exact same kind of stuff
and even if it generates HTML, JavaScript, Angular, maybe React or whatnot
your interface to handling all of that is one tool. So it's very well streamlined
I'm going to talk about how, now I'm going to talk about the platform itself
and when I open it up for question and answer, I want to make sure that you guys will talk about the previous items
that I just mentioned about software development itself. Moving on to Graphite, how do you build Graphite
Graphite not only helps you build a full stack with one tool
but it actually trains young developers into building applications that are well designed
Now, we know during development process, people sometimes start with a screen
they look at the screens that the user wants, build the UI, and then build the data model
and then what they have in their hand is a complete mess
In some cases, they start with the data model, build objects that just mimic the data model
and then build the UI after. A little better, but not really of any use
The real need for object-driven, the real idea of object-driven programming is to build objects that mimic the business problem
then build your data model based off of that object model, and then build your UI
Obviously, business logic attached to your object model. Very few people in my experience I've seen do that
Almost always people build a data model and then build classifiers that just mimic the data model
And so, we wanted to address that problem. So, when you use Graphite
the first thing you do is build your object model that mimics the business. There is no more linked tables
If a person has a list of addresses, you create an address entity
and then you create a person entity, and you add a list of addresses in person
You don't have to go create an intermediate table called person address, put IDs and things like that
In fact, IDs don't even exist in Graphite because they are handled behind the scenes
And then all business logic is built in the form of flowcharts. And we did that to bring in people that understand the business
and the developers together and remove that friction. What happens now is a person writes that document
gives it to the developer, the document's not well written, the developer writes the code
doesn't match, and there's a back and forth to fix that. What we said was
everybody understands flowcharts. If you simply give the developer the capability to do any written code in the form of flowcharts
then you can have the capability of having a business user sit with them to go through an issue that they're facing
and fix it. And you'll see when I show you the application
that it is really that simple. And then the UI. So we decided to build a UI capability
where you have the complete freedom to build any UI component, but once the senior architect or the senior developer
in a team sets the standard for what the team should be, what the multiple language takeover is
and what the components that should be used are, or the widgets that should be used
all developers in the team kind of stay in that paradigm. That's giving the end user a uniform look and feel
for the application that's being built. So moving on. Graphite is just not a code generator
Out of the box you get multi-language and multi-currency for free. We built a massive application for a company in China
and it took us less than a half hour to build the application ready in Chinese
So that's how quickly you can create a multi-language capability. Version control
So it connects to Azure DevOps, so you get all the features that you get in Azure DevOps
in terms of the SQL process, as well as checking, checking, branching
and things like that. So it's a really cool debugger. In fact, it's great to see young developers
use Graphite and learn the concept of coding logic using this debugger
Instead of going line by line, it goes shape by shape. So literally think of debugging a video flow chart
That's the kind of functionality that we have with Graphite. Smart refactoring is again something
that we saw in the academic circles when we first started the company
where a change done by a developer is simply checked in and everybody else breaks
We see that all the time. We wanted to address that. With Graphite, any modification you do
Graphite will immediately do a complete analysis of that whole project you're working on
tell you what it can automatically update and what has to be manually updated
And when you commit, it makes sure that you have done all those changes
so no one else breaks. Service API, you can export and consume
both REST and SOAP services with Graphite. And one of the things that we really wanted to address
is one big thing that proliferated the industry is REST services. Obviously, SOAP and REST have their own
different advantages and disadvantages. For example, SOAP is well-contracted. REST is not
Whereas REST is super lightweight and fast, SOAP is a little bit more heavier
But the problem with REST is that there are millions of REST services out there
in the world which are not documented. And even if they are documented
and the REST service changes, nobody updates the documentation. The software community has been trying
to solve this problem by introducing Swagger, which is now OpenAPI. And so what we did is
if you export anything in Graphite or consume anything in Graphite, it will be through OpenAPI
So if you go build a flowchart in Graphite and push a button to export it as a REST service
it generates the Swagger documentation for you. If you go in and modify the REST service
and change its inputs and outputs, let's say, and you recompile, that Swagger documentation is immediately updated
So you will never, ever be in a situation where your REST service
and your documentation does not match. And that alone is a huge advantage of Graphite
that handwritten code never can get us. And then Graphite also comes with a testing harness
Now, since it generates the code and it builds the application and deploys it
you really can use any of the testing applications and modules that you already have in place
But Graphite itself comes with a testing harness where you can test all the business logic
even before the application goes into test. What we have found is that people tend to..
the QA tends to get involved in the CLC process much earlier
than in traditional software development. Well, one of the biggest things that Graphite gives you
is application-level security. Any traditional, well-designed application or the people that believe
in writing applications that are solid will know that security falls in two areas
One is infrastructure-level security and the other is application-level security. When you take terminology like
cross-session IP scripting and things like that where you have to put stuff in your application
to control ports, then you automatically know that you're doing something wrong
I've seen a lot of these security principles move from infrastructure-level into applications
And that is a no-no, but people seem to completely ignore those very important principles
Having said that, application also should have good security principles. And those security principles
can all be automated. But the problem is, since you're handwriting code
it's very difficult to automate them What Graphite does is using Graphite, all of that stuff is automatically handled
When you're coding your flowcharts, building your entities, or building your web services
you don't really have to say, I need to worry about SQL injection here
You will never be in that situation because you will never type any SQL while you're building applications
SQL will never be generated It will all be linked expressions. Auditing, for the sake of Sarbanes-Oxley
you've got to make sure you have auditing. Some people develop tables which have auditing functionality
and some people forget. With Graphite, you don't have to worry about it. You never mention the concept of auditing
when you're building your entities. Everything is generated behind the scenes. Even simple IDs coming back to the page are encrypted
So you have absolute security. JavaScript and CSS is minified when you do a release build and so on and so forth
So you get absolute security when you build a... In fact, we give a perfect code security guarantee
for all of our clients. I wanted to talk about the stat that Graphite generates
The one thing to note about Graphite is nothing is proprietary. Once you sit in front of Graphite, you visually build
the ETL, you visually build and I shouldn't even call it ETL because it's
object relationship. You build your screens you build your business logic in the form of flowcharts
Once you push build everything after that is something that you are already used to
So once it takes that visual component and turns it into a simple C-sharp stat with HTML, CSS, JavaScript
and C-sharp with MVC pattern it then uses industry standard or Microsoft standard technologies
It uses MS Build to compile it and create a binary. It uses WebDeploy to deploy it to
IIS. So you literally have and it uses SQL Server and obviously
uses MV Framework to convert objects to the data models. So again, nothing, there's no magic inside Graphite
All it is is a nice clean visual frontend that brings in
business users and developers together and give developers way more control with respect to what you're doing because you get to look at
the code that's generated and critique it so it keeps us honest to make sure
that absolute perfect code is generated and invariably we actually see that developers actually learn
real good ways to write code by looking at the generated code
We oftentimes see that. Many people look at a tool like Graphite and go
wait a minute, am I leaving what I know and moving away to something else
You're really not, you're still involved with all of the things that you're dealing with. Now if you don't want to deal with any of this
then you can stay right inside Graphite and build your applications which we see young developers come in here
and almost always they build better applications than any handwritten code which they quickly realize and then they get
the curiosity to go in and start looking at what has been
generated and really understand those concepts in the right way. Graphite again has
it can deploy to any cloud but if it deploys to Azure it can really use
all the power of platform as a service using Azure App Service and Azure SQL
With that I'm going to jump into showing the platform. What I want to do is I want to show an application
which is a very complex application that we built. It was for FEMA
for people that are not in the US, FEMA stands for Federal Emergency Management Agency
it's a US government agency that takes care of massive floods and things like that to go and provide
support there. They provide flood insurance for homeowners and this is a document
they gave us, 600 pages worth of requirements document but if you
go to page 83 about 20 pages actually is one single calculation
it's one calculation to calculate the premium for the homeowner. I'm going to show, when I show you
the product, I'm going to show you a screen that takes in all the inputs and calculates that premium and then I'm
going to jump into the platform and actually show you how we
turn that calculation into an actual development project. So if we go into
this is the application as you can see National Flood Insurance Program. I'm going to log in as an agent
this application was built to handle new business which is where an agent enters an application when they're sitting
at a homeowner's house. Then it goes to the underwriter so the underwriter can
can actually approve that policy. Then it goes to customer service rep
to handle all the day-to-day functionality of the policy and so on and so forth. Obviously you saw a little bit of lag
there that was because I'm running it locally on my machine and I didn't have AppWarmup running
So here's one of the screens one thing about Graphite is as you design these screens
if you decide to if you decide to you know have RWD it automatically takes care of for you
you don't have to worry about as you drag and drop Graphite elements it takes to make sure that
RWD compliance automatically happens another huge benefit for developers to increase productivity
Here I'm going to go into this get quotes screen and I'm going to try and enter
test rates that I had put in so I'll quickly choose some stuff and push calculate
because we're going to see the code behind this quote button Let's just quickly go through this
The house was built in 1925 I want insurance for $50,000 and $10,000 for content
I push quote and it basically calculates that quote seven times so 1, 2, 3, 4, 5, 6, 7
So you can see those 20 pages worth of calculations almost instantaneous. So performance is another
huge thing and of course when you push apply it'll go to a screen where they enter the details and stuff like that
So now I'm going to actually close Graphite Let's just jump into the product and actually
look and see how we created that So double click on Graphite, it opens up the last project
that I've been working on which happens to be the same project as earlier this morning
I went in and I did a build to deploy it on my local machine
So if you see the look and feel it doesn't look like any other IDE It looks completely different
The problem we see with people that build new IDEs, they are
chained by the previous IDE and they think everybody needs to have the same IDE
We wanted to look at it differently. We want to say we're going to build an IDE that's going to be the future
We want to build an IDE that brings in more people into the development life cycle that a company goes through
So we looked around the academic world on where there's research related to it
And MIT had serious research in this area And the term they used to call it at that time
when we began the company was called Domain Driven Design So we took that
It made absolute sense and we decided to take that So what you see here is these blue boxes are the different
domains within your project These are all the objects in your project that relate to the application
the insurance application for buying flood insurance. So if you go into the application
object itself, this is an object. So think of this as a class file for developers
on this presentation. You see there are no IDs and stuff like that. What happens is
this becomes a class file when it gets generated And then this then uses any framework
migrations to actually create the database table which I can show you guys in a few minutes
So these applications then have behavior. So these are the public methods
inside that particular class file What is really cool about Graphfile for senior developers
is they can very quickly do code reviews For example, when I come into a
class file and I see like 30 properties here, I immediately know the developer
didn't do the right work to do proper design So I will ask them to go change it to see
how to make that size of that entity smaller by grouping things that relate to each other. So very
easily you can do your code review. Not only that, Graphfile has
a warning tree which will have all of the stuff that you set up as
things that concern you and it will bring it to highlight and you can
take it up with the developer that's reporting to you Let's look at
a behavior. So generate application number. So this is how behavior is all written
As you can see, with these 25 odd shapes, you can write any code
that you would otherwise write in any language So equal to is a sign, create is new
create from is casting, evaluation is simple expression, list management handles everything to do with lists, this diamond shape
is a hit statement, this dotted line is a loop So as we all know, logic is logic
So you can write logic in C-chart You can write the same logic in Java
and same logic in C or what not, it's just that the syntax
changes. So think of the syntax as a shape and when you double click on the shape, here is where
I'm initializing an integer to 10 Here I'm initializing another integer, but I wanted
to show you a hit statement Here's an hit statement, such that raw application
number is less than character limit So it's literally code. So with these 25 shapes
you can literally do anything you have you need for a business application
and notice I said business application One of the biggest things that we often find
when we are dealing with companies that are struggling with applications is in a business application
a developer goes in and puts a lot of systems applications complexity
software applications are divided into two groups application programming and systems programming
Now you take something like BitArithmetic There is no reason to use BitArithmetic
in application software but developers who have launched it somewhere they introduce that and then end up finding
there is huge maintenance nightmare 3-4 years from the time they built the application
So what we have done is we have restricted these shapes to really make sure that only
constructs that you should use in application programming are needed Let's say someone says, oh my god Chris
I can't use this, I built 80% of my application So the library I'm using needs BitArithmetic
What do I do? Graphite actually gives you a way to call external DLL
so you can write any code that you want that you believe that Graphite cannot do
which we rarely find In fact we probably found it once throughout the last 10 years of client
It was resizing an image In Visual Studio we built a class file
which exposed a behavior called resize image which took in a string
and returned the base64 for the resize image and in Graphite we simply connected to the DLL
we saw the method it exposed gave the method a name and then came back to the flowchart
and there is one external process So what I mean by that
is you will never be in a situation with Graphite where you will say I've done 80
for this other 80% Graphite shapes are not letting me do it You will always be able to write code outside
and then call it from within Graphite So let's come back to
seeing what's behind the quote button Let's say you are good with Graphite
and someone is telling you to go figure out stuff behind the quote button
This is how easily I get to the code behind the quote button I copy the HTML file name
I paste it in the search It shows me all the components that have that word
Here I can see from the logo that it says screen I double click on it and this is how you build your widget
So here are all your widgets in Graphite Graphite comes up with about 200 widgets
but guess what? You can build your own widgets So if you find something cool on the internet
that you want on your web page within minutes you can bring it in as an icon
and then drag and drop it and you will be able to put it on any screen
So here is your palette where you drag and drop this hierarchically and Graphite decides how to visually show that
The reason why we did it instead of visually is to give the senior developers control
over what their team is doing So you don't have a rogue developer that goes in and
changes button colors for all his screens to orange instead of blue as you may have decided
Having said that, Graphite gives you a capability to control multi-teaming so almost all of our applications look different from each other
So you have your own teams, there is CSS behind it You create your team, you make sure each one of these
falls into that team and now your team is following the same team throughout your application
So anyway, coming back to this to find out what happens behind a quote
I push the control button, I click on it, I see the properties of the quote button and on the on click I actually see
the quote button here and this is the flowchart that is literally doing what is behind the quote button
and inside here I'm going to go into this flowchart just like what I did right there was
equal to right click, go to implementation This flowchart is what calls 7 or 8 other flowcharts
gets their results, adds all of them and calculates the total team you do
which you actually see here So if you go into some complex stuff like let's go into
you go to calculate, you go to find rate table so you can see like it's just called function after function
and the cool thing about Graphite is documentation. Let's take a look at this
calculate rating flowchart which is under NFIP insurance data entity, right Anytime you see these three boxes in Graphite
if you click on it, it will actually do something related to documentation
and shows where all calculate rating is being called as you will see it's being called on on click quote
see on click quote button but more importantly it shows every method that it calls
and you can see a figurative representation of everything that's happening in calculate rating
and in fact when I was showing this to one of the actuaries
who was really good at Excel but didn't know coding he wanted to see what this determine ICC premium did
and when I clicked on it he literally read these English sentences
and said yup that matches what are my calculations and the beauty of this
is when you double click on this page that comment that you see here was never typed by anyone
actually Graphite looks at this list lookup and it generates this comment
for you, not only that this generated comment then ends up in the generated code
so when you go to Graphite and do a build and in fact what I'm going to do is I'm going to do a release build
so I can show you the code I'm going to do a release build
and we look at this determine ICC premium and then I'll actually
stop and open it up for questions I'm going to do a build
what it's doing is taking all the visual stuff turning it into a full C sharp project
then it's using MS build to compile and then it's going to use web deploy to deploy
while it's finishing up I'm going to show you the generated code
as you can see it's 11.39 here in the UX it generates two C sharp projects
the web project generates all the HTML pages and the controllers the library project actually generates all your business logic
so in case you wanted to split the application in the DMV and behind the firewall you could do it
but here if you want to see that determine and I'm not going to open this up in Visual Studio
which we can but if I want to look at the code
notice the generated code it's absolutely pristine every indentation everything is actually
mapped by style cop rules and you see these comments here in the sub matching
ICC premium tables by the way when you're doing a release build
this is going to take about 40 seconds because it's taking all the JavaScript and CSS
and compressing and obfuscating it when you're building debug mode this is literally instantaneous
and I can show you once it's done the amount of lines it has generated
it generates about 500,000 lines of code and that's just the C sharp stuff
so that kind of gives you an idea you can see that the generated code is absolutely pristine
what that means is we wanted to address problems with products like Power Builder
and SQL Windows and Delphi once the web world came in they became irrelevant
we did not want our clients that use graphite to be in that same place
you have the absolute generated code here number one, if you decide you don't want graphite
you can continue with the generated code your productivity will drastically reduce
if you're doing 10 times faster you're going to go back to what it takes with traditional code
which will be much slower number two we will be upgrading graphite
to generate the latest stack for example, this is .NET Core Framework 4.7
we are now going to release in November along with Microsoft graphite will generate .NET Core
what that means is this project that was generating .NET Core if you open it up in the later version of graphite
and push build it's going to instantaneously generate .NET Core code your upgrade procedures become a matter of
days instead of months that's a huge advantage we see with all of our clients
we have an application that we built for a federal agency that all the applications put together
like 8 applications 8 massive ERP applications total generates 6 million lines of code
when we first created graphite it was generating .NET Framework 4, we upgraded them to the latest
and it took us like a month to do that whole upgrade process
and that is obviously unheard of with that I will open it up to questions
let me just quickly show you guys one thing if you look at
let me take a flowchart determine range if you see, if I wanted to expose this
as a REST service, all I have to do in graphite is click on that, I can expose it as REST
or scope and then make a post and give it a name
right and click ok the next time I build, it will expose this as an end point
and not only that, generate REST documentation for it, if I go to the sidebar
go to services, I will see all the stuff that has been exposed already
as you can see, determine ICC premium has already been exposed and if I wanted to see the swagger documentation
and I want to see the REST swagger documentation I can double click on this link
and you will see the open API documentation that is generated for you I just did a build, so again it is going to do a warm up
and here is all your swagger documentation automatically generated for you that alone is worth its weight in gold
if you work with graphite with that I will open it up for questions
I will put myself in that or you got it yes Chris, I am observing the Q&A session
so far there is no question in queue ok great so probably you may want to continue with your
demo while waiting for any questions to come ok, alright great, so what I will do next is
show how you can get graphite if you are interested in it so if you go into the graphite website
which is graphitevpc.com, you will learn quite a bit about graphite if you go to the pride free section
you will be able to download graphite and the initial system libraries
that you will need to build the first application the system requirements document will tell you
what kind of machine you need and install nodes if you have any trouble installing
or like you need NVC and stuff like that some machines don't come with that
this will help you get through that stuff and graphite, there is no trial version and stuff like that
in terms of features when you get graphite you can build any application
all the applications that you build will run for 30 days and then if you want to extend it
you just have to go to a screen in graphite and extend the trial and then you will get another 30 days
and if you want to make it production worthy your contact us, we will give you a key
and then you won't have this issue anymore if you go to this knowledge center
which is kc.graphitevpc.com there is a lot of stuff in here that will help you learn graphite
if you go to the references section there is a whole bunch of documents here
that you can literally open and here is a beginner guide that you can use to learn graphite
step by step if you go back to the home screen there are youtube videos for graphite
that will help you learn graphite by going through this playlist you can learn how to use graphite
and then you have these other things this section shows you what each shape does
and then you have the section that talks about all the widgets that are available
for example if you look at buttons and these are stuff that come through with graphite
we have other libraries for example we have libraries that does maps
we have libraries that does payments using stripes and so on and so forth
we are also in the process of building an app store where people can create graphite libraries
put it up there for conjunction by the wider world and then you have these other things
that you can use to learn graphite and then you have these other things
that are available for you and then you have these other things