>> [MUSIC] >> Hello, everyone.
Everyone's dancing. We're on another
episode of On.NET Live. Welcome to 60 minutes of
Unscripted.NET Entertainment. Our mission is to empower the.NET
community to achieve more. I'm your host, Maira Wenzel, with my co-host, David Pine. >> Hello. >> And Cam Soper. >> Howdy. >> I'd like to welcome
today's guest, Shaun Walker. He's going to be talking to
us about Oqtane at CMS and application framework for Blazor and.NET [inaudible] We're
going to dig into that more, but first of all, Shaun, why don't you introduce
yourself a little bit. >> Sure, I'm very excited
to be here today. I guess my claim to
fame is that I was the original creator of an open source project
way back 20 years ago. That was called DotNetNuke. It was later renamed to DNN, but that was my first big
experience with open source. We created quite a large project, created a company, raised three rounds of venture
capital around that. It was quite a journey. I parted ways with that in 2014, and I've been involved with
various things in the. NET community ever since. I'm a Microsoft MVP, I think I'm in my 15th
year as an MVP now. We're going to be talking
about Oqtane today, which is my latest
open source project. I'm also involved with
the.NET Foundation. I've actually been a volunteer
with the foundation since 2014. Coming in almost a decade of
participating in the.NET Foundation. A couple of months ago, I decided to take a
leap of faith and left my job that I had and created
a couple of new companies. One is a consulting
company called Dovestone, which is really focused on Blazor
and modern.NET development. Then the other company
is Oqtane Labs, which is the steward of the Oqtane open source project that we're going to be
talking about today. >> Awesome. I saw Cam react
when he heard about [inaudible] >> I'll just jump in here. I live in Kansas City, Missouri, and I was employed way back from 2000-2007 by Commerce
Bank here in Kansas City. Within our little area
of the IT department, I recognized the need for a
CMS and wouldn't you know it, that DotNetNuke is what came up. I've implemented DotNetNuke. I introduced it to all my coworkers. I loved DotNetNuke and I had no idea you were the
creator of DotNetNuke. >> I didn't realize that either. I was like, wait what? >> Yeah, it shows your
age, I would say. But no, I shouldn't joke. It really was an
interesting solution for the time period that
it was released in. It had a lot of adoption
and still today there are a lot of companies that are still deploying solutions
based on DotNetNuke. It's definitely far outlived what I thought it would when
I originally created it. >> It's awesome. >> Yeah. Like if we don't
want to date ourselves, let's not say how
much it would've been coding in DotNet and
those kind of things. >> It was introduced in
like DotNet Version 1. That's going back a long time. >> But we're here today
to talk about Oqtane. I don't know if you want
to start with your slides. >> Yeah, sure. I can give you a little
bit of an elevator pitch. Since a couple of you are already
familiar with DotNetNuke, this is all going to seem
very familiar to you, sort of like a DotNetNuke V2. I guess the reason why I
started off on this path with Oqtane is this has always
bothered me in the.NET world. When we build applications, they're really complex,
they're very sophisticated. But the examples that we're given to start with are often
like Hello, world. Something that is so
simple and not realistic, that it takes us a lot of time
and effort to actually figure out how to build a really robust
enterprise grade application. That's always bothered me. When I originally
created DotNetNuke, I was trying to solve that problem. When I got involved with Blazor, which was back in 2018 when it
was still in a preview phase. I felt like the examples that were available for Blazor were
also way too trivial, way too simplistic for building
a really robust application using that technology and I
thought there's got to be something better
available for developers. I thought, okay, I can execute on this same playbook again
that I did with DotNetNuke, then I can create an
application framework. I can base it on Blazor, I can base it on.NET Core, and I can provide a pretty solid foundation for developers to build
applications on top of. I think we're all pretty familiar
with what applications provide. They're designed to accelerate the development of the work
that you do as a developer. They do that by providing some standards that
you can build around, some patterns that you can follow. Then they try to automate a lot
of the things that you would bump into if you just tried to build something from
scratch by yourself. I guess the other aspect of this was code reusability has always been a big topic that
I've been keen on. Going again, way back to the
original version of.NET, I felt like the original
Web Forms model had a lot of code
reusability built into it, especially on the UI Stack. Once we transitioned into MBC, we lost a bit of that, I would say. But then once I saw Blazor, I was super excited
because I realized we could get a lot of those great
capabilities back again. I thought, this is definitely something that needs
to be built into this framework is a heavy
focus on reusability. Following the same architectural
model that DotNetNuke followed, I thought I should build
a modular application. I think that a lot
of people understand that the concept of modularity, so you build things in independent manner so that they're not tightly
linked to one another, and then you can deploy them
independently from one another. There's a lot of
different names that people apply to these types
of applications today. Composable applications,
micro-services, micro-frontends, modular monoliths, vertical slices, there's a ton of
different names but they all boil down to
basically the same thing. I think the problem is that if you asked most.NET developers today if they're building
modular applications, they would say, yeah,
absolutely we are. Then you would say, well, okay, can you tell me how you're doing it? They'll say, Well,
we're using NuGet. Okay, maybe you're building composable parts that are
packaged up as NuGet packages. But really, that's only
part of the story. Because by default in the
Microsoft development world, NuGet packages are really a
development time concept. But when we're talking
about real modularity, we're talking about the ability to deploy independent bits out into your production environment
instead of having to do a wholesale push of
everything every time. I see that the default patterns
that people follow today. Yes, they're using
NuGet for development. But when it comes time to
do actual deployments, they rely on the Microsoft tooling, which of course forces you into doing very monolithic
type deployments. Oqtane wanted to
embrace full modularity and so that means everything from development all
the way through to deployment. I guess another big aspect
that I wanted to focus on, and this has always been
a huge focus of.NET Core, which has of course been re-branded
to.NET now is performance. >> I guess my experience with Web
Forms and building DotNetNuke, over time it became
pretty apparent that stack had some performance
limitations to it, which obviously Microsoft
also recognized, and that's why they
introduced.Net Core. But this was a key capability that I wanted to exemplify as part of
the Oqtane framework as well. Is that always a heavy
focus on performance. This doesn't mean just
run time performance , benchmarking run time, this means all aspects
of performance, like how quickly can you get a development environment up and running so that
you're productive? How quickly can you iterate on your code and push out new versions? All of those are aspects of performance which you need
to take consideration of. That led to the
introduction of Oqtane. The high level goals
were to accelerate the development of modern
digital experiences. It does that by providing a set of building blocks and services that you can utilize in
your applications. It's fully open source, licensed under an MIT License, and it's been a member of the.Net Foundation for I think
about three years now. Since the very beginning of Blazor, it's been really pioneering
the adoption and usage of Blazor because it really takes advantage of the
Blazor component model as part of its modular capabilities. I guess the other thing that I
wanted to do right from the outset, which I did not do at DotNetNuke, because I wanted to actually formalize the philosophy of
this open source project. This is pretty important because once you start maintaining
an open source project, you're going to have a lot of different stakeholders
who come to you and say, I really wish it would
do X, or Y, or Z. If you don't have a
philosophy to point to, it's really hard for them
to understand why you would say no to some
of these requests. By formalizing these pillars
of a philosophy early on, it made it clear to the community, this is the goal of the product, these are the areas that
it's going to focus on. If it's outside of that realm, don't be surprised or if basically
your requests are denied. I think that this is also an aspect of open source that
people don't understand. Open source projects are built
around someone's vision. There's plenty of times where that vision doesn't align
with the usage that other people might desire. However, in that case, then there's always the
ability to fork the project, make it do what you want and create your own
version of the project. That's one of the
freedoms of open source, but obviously if you
stick with the philosophy and work together on
the same road map, you often end up
with better results. Conceptually, the
architecture for Oqtane, this is probably not for
anyone who's technical. It's not too surprising, it uses the client
server model that is popular and is almost a basic
requirement within Blazor. I think that the interesting
part here is that one of the goals of Oqtane from
the very beginning was to support all of
the hosting models. Not just cater to one
specific hosting model. In order to do that, we really had to embrace the
client server architecture. Because of course,
it's possible to build Blazor server applications
that are not client server. Where everything runs on
the server and you don't have to worry about client
server architecture, but the moment you
want that application to run on Blazor WebAssembly, of course then you need it to be
a client server architecture. That was always the approach
right from day one, both for the core
framework and within all of the application templates that the framework provides
for developers to extend it. On the server side, of
course, you've got.Net Core, you've got EF Core, you've got the Oqtane, which uses a repository
pattern for doing data access. It's also got its own
headless API layer, which of course is required as
part of a client server model. Oqtane is also using UI hosted
service capability as part of.Net to allow for asynchronous scheduled jobs
to run in the background. We're going to tackle the fact that it's a multi-tenant in a minute. On the front end, it supports Blazor Server WebAssembly
and hybrid models. It has its own service layer that it provides so that
it makes it easy for developers to be able to call
the back end API endpoints. It has a composable UI model, which I'll explain more in a moment. Moving on to multi-tenancy, this was a key capability
that DotNetNuke provided and I think
it's one of the reasons why it had such high adoption. Basically, multi-tenancy is a virtualization
concept that allows you to serve the needs of multiple clients within
the same infrastructure. Obviously, there's other ways to
achieve multi-tenancy as well. You could use hardware
based multi-tenancy, you could use containers, but if you want to use an
application based approach, then there are certain
things that you have to do. I guess this is something
that Microsoft has never really provided support for by default within the
various bits that it provides as part of
the.Net Framework. This was always put on
as a responsibility for application providers to build multi-tenancy into
their applications. Oqtane supports two different
types of multi-tenancy. It supports both an isolated model where you can have the same runtime, but have your client
databases separated, so separate client data
stored in each database, or you can have a shared model where the client data is co-mingled
within a single database. Of course, it depends on what
your needs are as a business. If you really need to have strong
isolation between your data, then you should go with
the isolated model. If you perhaps you want
to save some money and not spin up as many databases, you can use the shared model. I guess the one thing
I'll point out here is that DotNetNuke only supported the shared model which certainly did have some challenges
in certain environments. Also, it had challenges when
it came time to perhaps migrate one of your tenants out of an environment
into another environment. You had to disentangle all of
that data which was co-mingled. Whereas if you had isolated
the data to begin with, migrating is actually pretty simple. From a database perspective, Oqtane uses EF Core, and so it's able to support
multiple database engines. Support SQL Server, support SQLite, MySQL, and Postgres. It supported these for, I think the last two or three years. When Oqtane was originally created, it only offered support
for SQL Server, which was fairly limited in
the sense that it's a.Net Core based application and it
should be cross platform. In order to be cross
platform then you really need to embrace other types of databases which are more native to those other
types of platforms. This was a big feature that was
added a couple of years ago. It's interesting because I
find that it's not really a question of I need to use MySQL
or I need to use SQL Server. Often you'll have
heterogeneous environments where someone will want to use SQLite for local development because it's so simple
and lightweight, and inexpensive, and then
they're going to deploy the bits out to a Postgres environment or a SQL Server environment
for actual production. This model works very well for that. The other thing that Oqtane
introduced a couple of years ago was the back end for front
end security pattern. >> This came about as a
result of wanting to embrace external login identity providers. It just seemed that the
industry was moving in this direction and moving back to cookie based models for
web application and so the backend for frontend
architectural model made a lot of sense for that. It was a good fit for Oqtane and
so when that was implemented. The framework also provided support for Jot tokens as well
as an alternative, but those are more for
very specific use cases, like if you want to interact
with an external UI client, or if you want to communicate
with a backend remote API, perhaps you would
use tokens for that. But for interacting
with the web app, that's all done using
the BFF pattern. It was actually quite nice to
see that Microsoft decided to also embrace the
BFF pattern in.NET8, which will be out in
a couple of months. Oqtane, rather than only providing support for
remote identity providers also always had a
local off story and use the.NET identity APIs for that. However, it had to wrap those APIs, so that they were available
in a client server way. Also enhance them so that
they were multi tenant aware. The UI for identity was actually rewritten as made of
razor components, which is something that of course
Microsoft is also doing in.NET8. But this was something that
Oqtane did a couple of years ago. Because if you want to same user interface behavior and look and feel throughout
your entire application, then you're going to want that in your identity section as well as
the rest of your application. That was something
that even today is not really possible with
the current identity. That should be something
that's coming in.NET8, though. As far as Blazor hosting models, like I said, the idea
was that Oqtane should support all the hosting models. It supports Blazor server, Blazor web assembly,
and Blazor hybrid. I guess the interesting thing
here is that it doesn't just support this per installation, it actually supports
this per tenant. Because an Oqtane
installation is multi tenant, you can specify that for Tenant 1, I want to use Blazor
server and Tenant 2, I want to use Blazor web assembly. You can choose your Blazor
hosting model per tenant, and that's all still part of the same run time installation and same exact framework
installation as well. This ability to pick and
choose whichever Blazor hosting model that you want has been quite a powerful
feature for Oqtane. Of course, Blazor hybrid,
when it came out. It's not really a hosting model, it's more of an extension of
what Blazor is able to provide. The idea there is that if
you build razor components, you can re use those same razor
components that you're using in a web context on other devices like mobile and desktop and that's
what Blazor Hybrid provides. That allows you to have a
multiplatform UI capability. You can, of course,
support not just web, but mobile and desktop through
the Maui capabilities. On the UI side and this is where
we're going to talk in a minute about why Oqtane, has
multiple personalities, but it has a composable
component, UI, which means that it's
actually not static in the sense that in your
applications that you're building, they are actually composed at run time from many
different components. Rather than in the typical
Blazor approach where everything is statically embedded
within your razor components. You would have components
nested within other components, but they're all static
and declared right in your code and that would
make up your application. In Oqtane, these components are
dynamically injected at run time. All of the configuration for your various pages in your
site are externalized, actually stored in a database. At run time, that creates
a lot of capabilities. Meaning like you can add additional
routes to your application. You can change route names, you can re-nest things by
changing the hierarchy of them. You can delete routes, all of this without
restarting the application. Because it's all just configuration. Whereas, like in a typical
Blazor application, if you wanted to add
another page to your site, it would require building the page
and then redeploying your site. That can't be done. It's not something that could
be reconfigured at run time. This is why people like to refer
to Oqtane is also a CMS because this dynamic capability is often something that's part of
a content management system. >> I'm feeling the shades
of Sharepoint there. >> Correct. Sharepoint was also
very dynamic in its capability. Still is. Obviously,
Sharepoint is still a product. From a modular perspective,
Oqtane is a framework, the idea with an open
source framework, you try to avoid changing
the framework code itself. A framework provides
extensibility points so that you can extend it
with your own functionality. This is primarily
done through modules, which was the common term that we
also used when we created.NET8. But in the Oqtane sense, a module is essentially
a razor class library. But it's a razor class
library that has all of the client server
characteristics to it. It uses essentially the
Blazor web assembly template, where it has a client
project where it has all of the razor components and
the service wrappers. HDP client, it's got
a shared project, which is where your
shared models reside. It's got a server
project which is where all your end coins reside in your repositories and any other server side concerns that
your application might have. All these DLLs and static
assets are bundled into a new get package which allows
them to be dynamically deployed. Again, Oqtane uses a slightly
different model than traditional. NET in that the new get packages can actually be deployed at run time. This isn't just a
development time concept. This is a whole
aspect of modularity. You can deploy an individual module into your environment and without deploying the
entire environment. The other thing that Oqtane took
seriously early on was support for different cultures,
different languages. The framework itself
is fully localized. There's many different language or translation packages which
have been contributed by open source community
members so that the application can be localized
into their preferred language. More recently, Oqtane
introduced a marketplace. This was always a key part of
the.NET Nuke experience is that third party developers
could build extensions. Some of those extensions
were open source, some of them were commercial. If you were a.NET entrepreneur
and you wanted to build a product business and
you wanted to target.NET Nuke, you could build commercial products and sell it through
the.NET Nuke marketplace. That was always a key
enabler for the platform. That was something that was always
a plan for Oqtane as well and really happy that that's been released in the
last couple of months. There's now a full
Oqtane marketplace. I'm actually going to be
doing a presentation about this aspect tomorrow at
the.NET Foundation Summit. One of the challenges with a
product that is so versatile. It's like a Swiss army knife. It's multi tenant, multi language, multi device, multi database, multi ID, multi app. It's hard to position it
because it does so many things. It doesn't easily fit into many of the different categories that
exists for software today. Basically, we had
to pick a couple of personas for the framework
and so we'd like to see it has multiple personalities because originally the whole goal
around Oqtane was to create a web application
framework focused on developers for building
modern web applications. However, it's really hard for some reason to get away
from this CMS term. Like people just see the capabilities of Oqtane and
they're like, that's a CMS. It's like, okay, I'm
not going to argue, originally I argued with
them and they said, no, it's not a CMS, it's
application framework. I finally gave up on that and said, yes it's a CMS as well. It's a CMS that's targeted
at developers because it's not like a site builder. There's a lot of really
great site builders that already exist today
if you want to build a simple website and I would recommend that you use those site builder
products if you're building a simple static website. If you're a developer though, and you have some content
needs and you have very niche or custom
application needs as well, then you could use Oqtane
with advanced capabilities. In that sense it would be a CMS. To decor to these two personalities. I actually have these
two domain names, registered Blazor
Kit and Blazor CMS. >> I guess one of the other
things, in case there's folks that are watching this that wonder what the relationship is
between.NET nuke and Oqtane. There is a common feature
set between the two. They both support multi tenancy. They're both modular. They're both composable in the
nature of their user interface. They're both open source and
they both support localization. But that's all conceptual
features that are in common. From a technology perspective, they're like 100 percent different, where.NET from a technology
perspective only supported Windows. It's built on the.net Framework. Only supported SQL server, was built on the web forms UI framework was
completely server side, was a monolithic application and
only supported web as its device. Oqtane is cross platform. It is based on.NET Core. It supports multiple databases. It uses Blazer and MAUI for its client server in
front end capabilities, supports microservices,
and it supports web desktop and mobile through
the use of Glaser Hybrid. Completely different like if
you look at the actual code, you'll see like no similarities
between them at all. >> Interesting. We do have our
first question coming in Shaun, let me interject here real quick. David, from YouTube is asking, does environment need
to restart after module update or is
it a runtime dynamic? >> This is actually a characteristic of.NET is if you're
building a module, if it's a true modern.net
application module, it would use dependency injection. Dependency injection by
default using the default way in.NET can only register a
service as part of start up. When you install a new module
that's part of Oqtane, yes, you have to restart
the application. That's a limitation, I would say, of.NET and I've talked to
the.net team about this before. It seems like that there's no desire to figure out a way to
solve that problem. I would love it if it
was fully dynamic. There are ways that you can do
things that are fully dynamic, just don't use dependency injection. >> Got it. >> Cool. >> Awesome. Thank you. >> As far as the release roadmap
is concerned, like I said, this started way back in 2018 when Blazer was
still in a preview stage. It's had a lot of
releases since then. The latest Oqtane 4
was released in June, and that was the update to.NET 7. We expect to have an update to.NET 8 in fourth quarter of this year, soon after.NET 8 ships. I guess at the time that Oqtane was introduced there weren't of course, like Blazer was brand new, so there weren't really any, viable options as far
as frameworks that were targeted
specifically at Blazer. Now there seems to be, there's a few more applications or templates or things that are basically saying that
their frameworks. I think that the framework
term is a little overloaded. Again in the sense of
Oqtane what a framework is, it's something that can be upgraded independently of the applications
that you've built on top of it. Just like.NET or Blazer, and so you have this upgrade path
as you upgrade the framework, and it doesn't affect the
applications that you've built on it, assuming that we take care
of backward compatibility, which is part of our philosophy. Whereas, like if you use some of the other Blazer templates
that are out there, they allow you to create
an initial application, but then as you customize it, there's no way that you can upgrade that template without a
whole lot of manual effort. That's a pretty big difference
between a framework like Oqtane and some of the other Blazer templates
that exist today. I think we should
actually show something. >> Sure. While you're
transitioning over, we do have another question here. Antonio is asking,
are you doing this alone or do you have a
team of collaborators? >> I started this on my own in
2018 and it's a labor of love. I've been putting a
lot of time into it for quite a number of years now. However, it is an open
source application. There has certainly been a lot
of contributions over time. Like if you go to the
Github repository tan, you'll see that I think we're up to about 45 contributors at this point. There's definitely been a lot of interest and there's been
a lot of folks who have contributed bug
fixes, functionality. I have not built this
entirely on my own, but I have invested a
lot of time into it. >> Awesome. >> In visual studio, this is actually the code from
the latest Deb branch. If you go to Github and
clone the latest Deb branch, this is the code that
I have locally here. You can see that the way
that the framework is structured is the
client server model, essentially the Blazer Web
Assembly template model, where you have a client project, a server project, and
a shared project. In the server project, I've
got the app settings that Jason open here and it's got a few different settings
of course in it. But in order to do an installation, of course because Oqtane
requires a database, there should be a connection
string. It's blank right now. When we run it, it's going to launch into an installation wizard for us so that we can install
the application very simply. This is where you would choose- >> Wait a second. Real quick,
just so everyone understands it. Your settings are
blank to start with. >> Correct. >> Your framework is capable
of detecting that and instead showing like this
installation wizard. >> Awesome. Cool. >> Of course you can choose
whatever database you want. I'll just use local
DB since it's simple, I got to create an initial account. >> Of course, the password
is just password, right? >> Of course, because it's local. >> Provide basic details so that it creates my
initial user account, or can also supports
templates so that it can template out an entire site. I'll just use the default, but there's an empty site
template if you don't want any of the pages to be created. You create your own
templates as well. They're very simple to create. When I say install now it's going to go ahead and
it's going to run all of the migrations that are required for the database
that I chose of course. It's going to use that
template to scaffold a bunch of default
content into this site. Created a number of pages. Here I got a homepage. If I use this edit icon here, I can see that this home
page has a default pane, which is just a region
on the page and it has a module instance here. It's got another module instance
here and a third one here. It's got three different
modules that are dynamically injected into
this page at run time. The private page just got
a single module on it. But this demonstrates that
there can be some pages in your site that are private. Every page if I go into
the page management area, there's meta data, of course, stored for this particular page. But there's also permission. I can say who's allowed to
actually view this page. Administrators in
the site can see it. Registered users are
allowed to see it. But if I say all users, anonymous users are
not allowed to see it. Actually, if I log out, we'll see that that page is gone. If I go back in here again, log in, like I said before, you can create an
unlimited number of virtual pages because it's
all just configuration. You can put as many different
modules on the page as you want. We saw down at the bottom
here that you can have many different pane
layouts so that you can add these modules
to different panes. If you want to lay out the
content in different ways. Then there's a control panel
that's available through this cog icon where you can get
access to add additional page, edit the page capabilities, delete, but you can also choose from a list of modules that
could be injected. The additional text
module is the only module which is included by default and it is the ability to basically edit content
in different regions. But this is of course
where your modules, if you built them,
would show up as well. There's also a bunch
of admin modules, and I'm actually going to show
you that in a minute here. If we go into the admin dashboard, we've got a whole bunch of extra admin functionality
that is included by default. Site settings are important because, like I said, an Oqtane installation
can have multiple sites. Essentially, this is the multi
tenant capability within Oqtane. There can be multiple sites and each site is identified
by a unique URL. If you're in production
and those could be domain names if you're
running locally, these could be just sub-folders, local host and then my port
number/site two could be another site. I could have many different
sites that are part of my local installation as well. Each site can have a set of pages. Each site can have
its own set of users. Again, this is the
user management is using the identity under the covers. It also has extra capabilities beyond what the.net
identity provides. Like this profile
management capability, I can set up dynamically which profile fields I want people to maintain
in their user profile. This is what it provides by default, I can add additional profile
options for this site, or I can actually
remove some of these. If I don't want some of them. Then when I go to my
actual user profile, it uses those to dynamically
generate this form for me. It takes a lot of the work out of the way of building user management, profile management,
and things like that. It's also got role management, and this is where you can set up as many different types of roles
as you want and you can use those roles to define the permissions for various
items in your site. It's got a whole file
manager capability. You can define various folders, you can upload files
to those folders. Each folder can have its
own set of permissions. It's got to recycle bin for when you delete pages or modules
from your site. They go into the recycle bin initially so that you
can choose to restore them if you want to bring them back or you can
permanently delete them. It's got a URL mapping
capability so that when there are 404s that happen within a site, and this is super important
when you're doing like a site migration to Oqtane. You have URLs that existed on the old site that of course aren't
mapped yet on the new site. If 404s happen, they will be
logged in the URL mapping area and then you can go in and provide what the actual URL those requests
should be mapped to. Then you can provide that nice migration continuity between an older site to a new site. There's also visitor management. For anonymous users it's
nice to be able to both track them but also provide some level of
personalization around them. Essentially, what this visitor
management does is it just drops a cookie and then it can pick up that cookie and subsequent
visits to the site. Then you can of course say
personalization options around visitor. The event log is where every action that you perform
within Oqtane is logged. Not just errors but logins, logouts, events that happened
during the initial installation. If I add a new page, it'll be log. If I modify a page it'll be log. You got like the full audit
trail of capabilities. If there are errors that happen it will also be able to e mail the
administrator of the site to let them know that a
critical error occurred. It saves 30 days by default
of the events for a site. Site management is where you
would add additional sites, so you can have many different sites that are part of your installation. Each of these sites
can have a different, actually, if I say "Add site", we can say that we provide
some basic information, a unique URL for the site. The themes are the look and feel, which template you
want to use and which run time you want to
use for that site. You can choose Blazor Server, Blazor WebAssembly, or hybrid. Then you also have the ability, if you want to create a site that's
part of the master database, for the shared database,
you can do that, or you can create a
new database as well. To keep your data isolated
from one another. Module Management, this
is of course where it tells you I have the
Html text module installed. I also have a whole
bunch of admin modules. If I want to create a
new module for Oqtane, I can use this wizard and go into module management and I can
provide some basic information and it has some templates for
scaffolding out a complete set of code so that you can have a
functional module to start with. That scaffolds out a solution file, project files, code files, static assets, everything
that you would need to basically build a module. >> The other thing that
we have in modules is, of course, the ability
to install modules. This is hooked up
to the marketplace. If I wanted to install
one of these modules, like let's say it
was the blog module, I can click "Download". This is very much like
an app store model, where it'll download the
blog module from the, basically, this blog modules
on NuGet because it's an open source package. You can download it
to your installation, and then once it's downloaded, you can restart your application and it will automatically be installed, including running all of the
migrations for the database, and you'll have a
blog module that you can then add to a page in your site. >> Is there like a
registry somewhere of all the NuGet packages and
GitHub repositories that? >> Yeah. Oqtane.net is
the Oqtane Marketplace. Anyone can create an account here, and you can submit your products. By submitting a product, you basically provide all the
information about a product, like where the download is. It could be on GitHub,
it could be on NuGet. Those are the only two
supported locations currently, because people trust those
as download sources. They don't trust random sites. >> I was just going to say, do
you review these modules, or? Not necessarily that you would go fully under the covers with them, but I'm just concerned
about malicious actors. >> Yeah. Currently, there is no review
process for modules, and that was the exact
same case with.NET NuGet. There is a certain amount
of trust, I guess, that you put into, well, downloading anything
off the Internet. Currently, there is
no review process. That's how you can install modules. You can also install
themes in the same way. There's two default themes, there's a Blazer theme
and an Oqtane theme. If I go into my Site Settings and
I go into the Appearance area, I'm going to change the theme
to the Blazer theme for this site, and save it. The changes to that, the
typical Blazer look and feel, where you've got now a menu
on the left-hand side, and obviously, all of the pages
have accommodated that new theme. That's the theming capability. Theming is all based
on Razor components and HTML, CSS, standard stuff. Language management
is where you'd set up multiple languages if your site
supports multiple languages. Scheduled jobs are where you
would have scheduled jobs, like so background
processes that need to run. They're very simple to create. They're based on that, like I said,
the IHostedService interface. Like if you're creating
a scheduled job, right now there's none that
are registered because I just created this application. But there's ways that you
can set up a schedule, so they run at a
specific time of day. They can run every day. They can run every
week, every month. All of that is built in
for you. SQL management. You can run actual queries
against your backend database. This is more helpful
during development if you don't want to spin up something like SQL Enterprise
Manager or something, or use the tools that are
part of Visual Studio or other areas you can
actually run queries in here, or if you're doing diagnostics. >> Could you do like
fault injection and just drop tables and see what
happens? Don't do that probably. >> Yeah. You have to be the host
user of the site to get here. If you were a host user and you wanted to drop tables,
absolutely you could. System info basically just tells you a bunch of different details
about your installation. You can set some configuration. These are app settings. Then it also has the ability
to see a system log as well. It does have a system
update capability as well, meaning it will check to
see if the version of Oqtane that you're running is the latest version that's available
of the official releases. If it's not, it'll tell you that
there's an upgrade available. You can choose to do an upgrade, so very much like WordPress
or other sites can do. This was a bit of a feat
to get to work in.NET, but it does fully work. It'll essentially
download the framework. It'll spawn a process info, which will shut down your site, unpack the files, bring
your site back up, and your site will be
completely updated. >> That's amazing. With all of the stuff
that you've just shown, I've got a question. What is next and what
haven't you thought of? Because I feel like this is
pretty feature complete. >> Like any product, there's like infinite things
that can be done, but I think so on the roadmap, I think that the next
major features are, well, really.NET 8 support. That will be a big one that has to be done within the
next couple of months, and trying to figure out how to leverage the new
capabilities of.NET 8. Obviously, there's a lot of hype
around the new united model. By digging under the covers
on the united model, it has certain limitations that I've seen in the sense that it's
all based on static routing. Oqtane doesn't use static routing. Oqtane doesn't even use
the default Blazer router. Oqtane has its own custom route, so that it can handle the dynamic capabilities of being able to add routes
and modify routes, and delete routes at runtime. Static routing doesn't work. Hopefully, Microsoft has been thoughtful enough in
their architecture of the new features for Blazer
United that there's a way to make it work with
applications like Oqtane. I think there's going to be
a lot of work around that. Because I do believe that Blazer United is an
interesting approach. Especially for an
application like Oqtane, because there's a lot of content in the site that is static in nature, which could be served
from the server, there's no need for this module, for example, to be interactive
in a Blazer sense. It could be served from the server
and that's all that's needed, and that would provide
some performance boost for an application like this. Conceptually, it's a perfect fit. Technically, is it
possible with the way that the team has developed Blazer
United? Yet to be seen. >> Awesome. What about in
terms of if there's issues or other feature requests
from the community, would you encourage them
to go through Github? >> Everything is managed through the Oqtane
framework Repo and Github. Yeah. Like you said, all the releases are here. >> One interesting thing you
mentioned it's localized. We've got viewers from
all around the world, so if there's translations
that wanted to be submitted, is there a separate
Repo for that or? >> The Oqtane organization has a translations Repo where you can see some of the
different languages that are represented here. Arabic, Czech, French,
German, Italian, Netherlands, so Spanish,
Urdu, Vietnamese. There's a lot here, and yeah, this is a good place to add
additional translations. >> Awesome. That's great. >> I think that the challenge
though that I've seen with translations is that it's a lot of work to go through and
do the initial translation and provide all of the translated
values for all the keys. But after doing that, it seems like there's less
motivation to keep it up to date with new
versions of Oqtane which, that's always a challenge. It's a lot of work. I don't know how to
solve that problem. Maybe if there was multiple
people that were contributing to an individual language that would help instead of just
being one person. But that's definitely something
I've seen as a bit of a challenge. >> You're using Rex
X for localization? >> Using the standard, like the standard.Net based
localization for that. Rex X compiled into
satellite assemblies. That's something I guess
I didn't really cover. When we talked about modularity
at the beginning and how modularity needs to encompass not just development
but deployment as well. One of the other challenges with deployment around modularity
is that if you can imagine that you have a.Net based application and it's made
up of a whole bunch of different class libraries but they're not tightly
coupled together. The dependencies aren't
necessarily known. It means that at run time, the application needs to figure out on its own what
dependencies that it has. Because the.Net runtime isn't
going to figure that out for you. By default, the.Net
runtime is going to load only the things that the
Oqtane framework knows about. It doesn't know about all of the third party components that
you are using in your site. Oqtane has to download those, or it has to recognize
that they exist for one, and then it has to load those into the app domain so that
they're available at run time using reflection to be dynamically injected
into your output. Then to take that one step further, when you're using something
like Blazer web assembly, the client browser needs to figure out which assemblies need to
be downloaded to the browser. You can't rely on Blazer
to do that for you. Again, that's something you need
to take responsibility for, and that's what Oqtane
provides for you. Similarly for Maui, it also
needs to download assemblies. Actually, I'll show you
that in a minute here. I still have Oqtane
running somewhere here. I have this site running. Then I have a Maui solution
as a separate solution. Right now, I have this Maui solution pointed at the same URL that my
web application is running from. I haven't configured to use my Windows machine as
my emulator for Maui. If I run this, it should run
my Windows device, and boom, what it did behind the scenes
is it actually interrogated the Oqtane server to see which modules it needs to download
into this Maui instance. It pulled them down dynamically, it then loaded them into
the app domain so that it can instantiate them within
this Maui container. It's smart in the way it
does it because it uses hash codes to determine if
those DLLs have changed. If I run this application
a second time, it's not going to download these
DLLs unless they've changed. There's this auto-servicing
capability that's part of Oqtane as well so that you don't
have to manually update your client installations. For example, if it was
a desktop installation, you don't have to go and update
your client installations. If one of your module changes, you deploy the module to the server, it auto updates it for you. You got full
functionality within Maui to do the same types of content management things
that you can do on the web. It's high fidelity, exact same
experience because we're sharing the same components
between Maui and Web. Hopefully, you've blown your
mind here a little bit. There's so much that's part of this Oqtane framework
at this point. I definitely think developers, rather than building
something from scratch, should be checking
this out because it provides just so
much out of the box. >> Awesome. >> That's what we noticed
today is that there is a lot of functionality built in. Thank you Shaun for providing
that to the community. I think I encourage folks that were watching to go check it
out and give it a try, contribute to the localizations. I noticed there is no Brazilian
Portuguese there so I might go there later on. Thank you so much Shaun
for joining us today. We appreciate and I love
learning more about the project. Tuning for next week I'm
going to butcher his name. We'll figure out how to
properly pronounce it, but he's going to be talking about
Newvin for C-Sharp Development. Thanks for hanging with us here
today and watching On.Net Live. You can check out
other great.Net live streams and videos at.Net/live. We have plethora of shows
every week, every day. Tune in next week to check
out the new show. Thank you. >> Bye. >> Thank you, bye. >> Thank you. [MUSIC]
