Categories
Enterprise Application Development

RAD Architecture Series: Data Model Layer

In continuation of our march towards understanding Rapid Enterprise Architecture, today we will talk about Data Model Layer in WaveMaker.

In any modern day enterprise, there are many data sources that applications integrate to, and these data sources are distributed, diverse and provide varying degrees of real time data.

Modern day applications need easy and sophisticated mechanisms for Data Manipulation and Data Management. WaveMaker abstracts out all the complexity, low level data manipulation needs and presents a unified REST API Layer for any type of Data Source, thereby significantly improving the productivity of an application developer dealing with data management and data integration.

In case of WaveMaker, application can integrate to a variety of data sources. They include,

  • All standard SQL Databases
  • SQL Queries, Stored Procedures
  • REST APIs
  • Web Service APIs
  • Web Sockets
  • RSS Feeds
  • Custom Data Source (Written using Java APIs)

The diagram below shows a unified architecture, that allows all the data sources (irrespective of its type) to be surfaced to the application as REST APIs.

As an Application Developer, one need not worry about the underlying complexity of the Data Source. WaveMaker simplifies it by presenting a REST APIs / Endpoint to connect to the Data Source and manage it seamlessly.

As mentioned in the previous blog, the data source is then managed by Variables from the application. The Variables are bound to the UI Widgets. In this way, all the complexity of the data source and business logic is hidden from the UI developer and applications can be developed in a faster pace.

When it comes to Database as the Data Source, WaveMaker has built-in features that makes it easier to manage the information model. WaveMaker supports a built-in Database Designer that makes it easy to model the database schema using drag and drop mechanism.

WaveMaker supports auto generation of the ORM layer for the database tables. The objects are then abstracted using a DAO as well as a Service (REST) Layer as shown below.

WaveMaker enables extreme productivity in developing Data Driven Applications. Most of the data driven applications needs faster response, responsive UI, easy data management and real time data visibility. Using the above architecture, WaveMaker easily supports creating UI Widgets (forms, grids, lists, charts etc.) that can be easily bound using REST APIs to any data source on the back-end. Also since all the interaction is REST based, the user experience is seamless by using SPA UI pattern.

Categories
Enterprise Application Development

RAD Architecture Series: User Interface Widgets

Let’s continue our march towards understanding Rapid Enterprise Architecture, in this blog we will cover one of the most visible aspect of modern applications being the User Interface Widgets.

User Interface Widgets play a very important role in both the User Interface Design and the User Experience of the application. Both UI Design and UX Design if done right with users in mind, can make or break application usage.

WaveMaker Platform provides a number of User Interface Widgets out of the box for developers. In case of WaveMaker, the User Interface Widgets not only help in providing beautiful UI out of the box but also are designed to increase the overall productivity of Widget Interactions. For example, by default many of the Widgets give out of box pagination, default selections, security, templates etc.

In doing so, WaveMaker UI Widgets play a critical part in enabling rapid development of applications by enabling a lot more tasks than just front end UI development.

User Interface:
Modern apps dictate both sophistication and variety in terms of out of box widgets. Different use cases dictate various forms of the widgets being used. Widgets need to take care of flexibility and advancement in both form and function. Finally every widget needs to be responsive.  WaveMaker provides all the standard HTML5 widgets from lists, grids, containers, charts, forms, panels, and all other HTML5 controls that an app requires by default in responsive form. Explore the list of widgets. 

Back-end Integrations:
In case of WaveMaker, the widgets also handle the following common functions required in a full stack application,

  • Auto Wiring to back-end services
  • Managing CRUD Operations
  • Configuration of Widgets
  • Templates that provide default properties
  • Security (Visibility, Accessibility of individual fields etc.)
  • Pagination

WaveMaker leverages the concept of Data Binding by Angular, to bind Widgets with Data (View & Model). Widgets can be configured to bind UI Elements to specific fields of the Data Model provided by Variables.

The Variables provide data integration for the widgets. Performs updates and synchronization to the actual data services in the backend. Manages client-side memory efficiently with scopes.
The Variables,

  1. Holds the actual data rendered by the widgets
  2. Data structure used for binding, with attributes and related objects
  3. API source from where the model object is obtained (DB, REST API or Java Services)
  4. Events that control the updates between widgets and actual service, vice versa

In summary, WaveMaker Widgets are highly sophisticated that not only enable creating  beautifully looking UI out of the box for Web and Mobile Apps but also due to its backend functionality they can greatly increase the productivity in developing the applications.

Head over to WaveMaker Rapid Application Development Platform page to learn more about the features and frameworks.

Categories
Enterprise Application Development

RAD Architecture Series: Client-side Framework

In continuation of the RAD Architecture Series, we are going to focus on Client-side Framework in this post.

Good user interface and usability can have a strong positive impact on the adoption of the application by end users. At the same time, it takes good skills to build good user experience. It is not just science but an art that is mastered by a few.

Developing the UI for web applications has been very sluggish, unresponsive and difficult for many years.  However, in the recent past, with the advancement of client-side technology (JavaScript, browsers, standardization, frameworks), it is now possible to create sophisticated UI. However, it  is important that one selects the right combination to make all this work seamlessly and simplify the developer experience. Otherwise it still can get complex and messy for UI developers.

With WaveMaker Platform, the following aspects were evaluated before selecting the right framework:

  • Support for a Framework that encapsulates modern client side architecture while also providing ability for developers to easily customize client side behavior
  • Support for responsive user interface that can adapt well to modern devices
  • Support for Single Page Applications
  • Well-designed client-side MVC framework
  • Plug-and-play of jQuery and JavaScript libraries
  • Support for 2-way data binding between Model and View

And finally the most important one was selecting a framework that had support and backup of a large community of developers, users and enterprise adoption.

With the above considerations, WaveMaker chose to adopt AngularJS client-side framework. AngularJS was created by Google and has a big following among client-side developers and backed by a strong community. All applications including web and mobile developed using WaveMaker auto-generate AngularJS code for the client-side user interface.

With WaveMaker, all the client-side UI widgets are wrapped using AngularJS directives.

WaveMaker allows developers to drag and drop these widgets to create a sophisticated user interface. These widgets allow customization using properties and offer greater sophistication in terms of usability and support data binding with any backend sources.  You will  learn more about them in the next blog post in this series.

Another advantage of WaveMaker is that developers can customize client-side behavior by writing custom JavaScript as well as importing 3rd-party jQuery or any other JavaScript framework. Head over to Wavemaker  Rapid Application Development Platform page to learn more about the features and frameworks.

In the next blog post in this series, we will deep dive into the UI widget architecture. Stay tuned!

Categories
Enterprise Application Development

Laying the foundational architecture for enterprise RAD

Modern businesses demand greater agility, speed, and continuous innovation when it comes to applications. Apps are the lifeline for enterprise innovation. Additionally, end-users have raised expectations around usability, availability, and usage of apps. Enterprise developers have to rethink the type of architecture and approach to use while developing web and mobile apps.

Within the industry, analysts use various terms such as Rapid Application Development Platforms, Low-code Development Platforms, etc. to categorize platforms that enable quick and efficient development and delivery of apps.  As we explore such platforms, one subtle yet critical aspect that fosters a highly productive development environment is the app architecture enabled by the platform.

WaveMaker RAD Platform is built on a set of core principles that enables a modern app architecture. In this set of blog posts, we will talk about the various aspects of a modern app architecture enabled by WaveMaker. This is the first post of the series, where we explore the list, and then in subsequent posts, we dive deep into each one of them. Please note that the word app refers to both web as well as mobile applications across all the blog posts in this series.

There are various components of a full-stack application that impact the working and productivity of the application. The choices that are made for each component determine the flexibility and suitability of the overall application for meeting modern business needs.

Fostering modern app architecture by choices made for the following,

  • Client-Side Framework
  • UI Widget Architecture
  • Data Model Layer
  • Responsive Design
  • REST enablement
  • App Security
  • App Composability
  • App Scalability
  • Real-time Support
  • Cross-Platform Support
  • Mobile Native Support
  • Continuous Delivery
  • Deployment Targets

In the upcoming posts, we will talk about the choices made by WaveMaker for each of the above. We will also talk about how WaveMaker unifies all the above into a unified platform, thereby, providing maximum productivity for Mobile & Web app development.

So stay tuned, and let’s deep dive and create some waves!!

Categories
Insights

The Rapid Application Delivery (RAD) Reality

Traditionally RAD has referred to Rapid Application Development, a way of building applications that contrasts with the more formal Waterfall model. As you would expect, RAD produced results quickly using tools that generated the application code from a high-level description or definition (in other words ‘software design specification’). Readjusting the design specification meant the application could be regenerated, thus saving time needed to rebuild the application to accommodate business changes. So, as a corollary, RAD supported Enterprise Agility.

Shortcoming of Rapid Application Development

Such code (re)generation from a model or specification was done using code-generating tools* that focused on database applications – and that includes a lot of applications. The generated code was rarely as good as the code written by a skilled human programmer. But really, many applications did not need hand-crafted code.
The perceived need for highly performant code confined RAD tools to prototyping, and away from final production (real-life) applications. The generated code was hardly readable and very difficult to maintain. Neither could such code be taken into professional development tools (the modern-day IDE) for enhancement. This was a real blocker for writing production-grade applications.
Code-generation was really a tradeoff between how quickly one can hack an application together and the resources it needed at runtime. Indeed, the need for constant business innovation was changing the speed at which enterprise applications were being thought up and written.

RAD for live apps gaining acceptance

Two important factors have started to tilt the balance in favor of RAD or generated code: (1) consumerization of IT or increasing importance of user interface (experience), and (2) adoption of the cloud model or scaling through commodity hardware.
1. UX Factor. Good UX can be the main difference between a hugely successful app and a complete failure of an app in the hands of intended users.

Good UX balances amazing looks, engaging experience, and ease of use. These are not easy for developer teams to build into apps, neither is it natural for them. But with the changing profile of employees and customers, most enterprises are realizing the importance of front-end focused applications, and tools that could help achieve good results quickly.
2. Cloud model. The crashing cost of computing and storage means the primary concern of software development is no longer hardware scarcity and optimized resource utilization. Cloud platforms built on commodity hardware and horizontal-scaling designs have further relaxed the need for handcrafted and highly performant code.

Rapid Application Delivery is the new RAD

The factors that lead to the increasing acceptability of Rapid Application Development (RAD) point us to the inclusion of Rapid Application Deployment as an important supplement. This changes RAD to Rapid Application Development and Deployment (RADD), or simply Rapid Application Delivery (the new RAD).
This renewed interest in RAD is reducing time to deliver new apps – the time between when a business feels the need for an app and the time it is ready to use. A successful RAD platform may have to focus on all 3 elements involved in the delivery of applications: Development, Integration, and Deployment. Also, RAD tools need to assist in getting the UX to finish.
* Quoted from the book “Code Complete” By Steve McConnell. More here at Chapter 30.