Oqtane Philosophy

1/14/2020

By: Shaun Walker

Most products are created with some core principles in mind. These principles provide a central theme for all major product decisions. The theme for Oqtane is "performance" which is highlighted by the Oqtane brand name whose root word "octane" is a standard measure of the performance of engine fuel. Performance is a general attribute and for a framework like Oqtane it needs to encompass a wide variety of characteristics such as the speed of installation, familiarization, development, deployment, and interaction with the product.

This is summarized in our mission statement:

Oqtane 's mission is to provide a modular application framework which accelerates the development of modern digital experiences.

The mission statement is comprised of 3 main pillars:

Code - a modular application framework that enables developers to create and deploy highly functional web applications faster than ever before.

Community - an ecosystem of open source developers and commercial vendors offering products and services which leverage the vast framework capabilities

Content - the ability for administrators and content editors to utilize an interactive no-code approach for managing their digital experience.

In order to be actionable, a mission statement must also be broken down into concrete principles in order to provide the lower level guidance for managing the product. Some of these are outlined below.

Core Technology

From its inception, .NET Core has always benefited from a very strong emphasis on performance. In fact based on widely accepted benchmarks it is considered to be one of the fastest web frameworks available today. The Blazor component model is based on a single page application model which optimizes how the user interface is rendered in the browser to produce a highly responsive experience. Oqtane takes advantage of all of these high performance technologies to offer a high performance modular application framework.

Flexibility

One of the benefits of the Blazor component model is that it is adaptable to a variety of different run-time scenarios. Currently it supports a server-side model via SignalR, a client-side model via WebAssembly, and a progressive web application (PWA) approach which runs on both models. Blazor Hybrid is on the near term horizon which will allow support for native mobile and desktop application models. The goal for Oqtane is to support all of these run-time scenarios. In order to accomplish this, Oqtane is built with a clearly defined client/server architecture which provides the flexibility to adapt to a variety of run-time configurations.

Tooling Agnostic

Although Visual Studio provides a powerful set of functionality for software development, it can sometimes be overkill for solving specific problems and is not always available or accessible to all software developers. As a result Oqtane should not rely upon or take advantage of any specific features in Visual Studio. It should be possible for developers to be productive on Oqtane using other development tools such as VS Code, JetBrains Rider, etc...

Low Ceremony

In this context "ceremony" refers to the knowledge and procedures required in order for a developer to come up to speed and work with a framework. Obviously, the goal is to keep the amount of ceremony to a minimum so that developers can be on-boarded quickly and can be highly productive. For example, a developer can simply create a razor file which inherits from ModuleBase in the /Modules folder within the Oqtane solution, hit F5, and the framework is immediately aware of the module without requiring any manual registration steps.

Encapsulation

One of the core capabilities in a modular application framework is the ability to create custom modules. The ability to create and package modules independently from the framework is a critical requirement for many organizations, but is especially important for ISV 's who wish to sell custom modules as professional products. In Oqtane the goal is to encapsulate as much of the functionality as possible in the code itself so that a module is simply a package of one or more DLLs.

Microsoft Alignment

Although there are cases where it makes sense to come up with original solutions to development problems, it is generally an industry best practice to take advantage of the native solutions which are offered by the providers of the platform. This alignment helps to ensure that the approach is well validated and will be supported in the future. This focus on consistency also minimizes the time it takes for developers to come up to speed on your framework because they are already familiar with the approach based on their previous development efforts. Constantly focusing on creative new solutions, some of which may be slightly better than what Microsoft provides, can become a barrier to entry for new developers and a maintenance headache for the platform in the long term. Oqtane will utilize the Microsoft recommended approach as much as possible and only be creative in the areas where Microsoft does not offer a solution. A good example of this is that Oqtane uses Nuget for its packaging and deployment strategy as opposed to creating its own proprietary approach.

It’s Never Done

Too often in software development a feature is considered to be complete as soon as it delivers the basic functionality to an end user or administrator. Usually the moment this occurs, the developer moves on to the next feature. However this approach is exactly how tech debt accumulates over time. Instead, much greater emphasis should be placed on the run-time characteristics of the feature, how it performs under load or with a variety of different configurations. It is only after a feature has been put through this "last mile" of evaluation that it should be considered to be complete. These optimizations help ensure that a framework maintains its performance characteristics and integrity over time.

Practical Engineering

There is a tendency in frameworks to make them as flexible and elegant as possible so that they can be adapted to any theoretical use case which may arise in the future. The problem with this approach is that all of the layers of abstraction eventually make the framework overly complicated, incomprehensible to most developers, and next to impossible to test or maintain. In addition, they often lead to performance problems which are difficult to diagnose and resolve. Practical engineering is more of an art than a science, but Oqtane aims to provide a framework which is balanced and intuitive to work with.

Minimize Dependencies

Open source philosophy highly encourages the sharing of code so it is common practice for developers to utilize third party components to accelerate their development efforts. There are definitely some advantages of using third party components however there are also some disadvantages. License compatibility and compliance is an aspect of software development which most developers do not usually consider but is a very important topic when you are providing a web application framework. In addition the long term security, performance, reliability, and upgradeability of third party components also need to be carefully considered before they are integrated as tightly coupled dependencies of your application. The goal for Oqtane is to choose dependencies wisely and only include components which are widely used and industry accepted. For example Oqtane needed a common design system and chose to use Bootstrap based on its maturity.

Consistency

When it comes to software, people often have very strong opinions about how a product should be developed. However in many situations it is not a matter of whether those opinions are right or wrong, it is simply a matter of individual preference. That being said, the most important consideration when it comes to developing a product is to establish some guidelines, implement them at the highest level of your organization, and ensure that all of the related projects follow them consistently. Consistency is the key to making the product easy to understand and maintain in the long term. This includes multiple aspects including items such as coding standards, development patterns, and user experience. As a result, it is important for developers to understand and conform to the established guidelines in order to provide the best possible experience to the community. For coding standards, Oqtane follows the .NET Core guidance and for development patterns and user experience there are plenty of examples demonstrated in the current product.

Backward Compatibility

It is a well accepted fact that developer adoption for software development platforms is dependent upon 1) stablility, 2) backward compatibility, and 3) upgradeability from release to release. As a result Oqtane strives as much as possible to embrace a non-breaking approach to software development so that it can ensure a healthy community and ecosystem.

As mentioned previously the core principles described above are intended to support the overarching core philosophy of performance. If Oqtane is able to maintain this focus on performance it has the potential to be the preferred web development framework for modern applications.



An error has occurred. This application may no longer respond until reloaded. Reload 🗙