Categories
Enterprise Application Development

Reaping Angular Advantage with WaveMaker

As web application development evolved, usage of JavaScript skyrocketed. To address the variance in support of JavaScript, HTML across the different browser versions libraries like jQuery evolved to offer a layer of abstraction for the web developers, so that they can just focus on writing their application logic instead of worrying about the vagaries of browser support. Single page web applications started to become the norm as more code started to be written in JavaScript than ever before. JavaScript has also become the language of choice to deliver applications that run on desktop browsers and mobile phones. So web applications written in JavaScript are now in run in environments with huge variations in parameters such as device CPU & memory, network bandwidth, browser support.

Powering this scale of growth needed the emergence of more JavaScript frameworks that provide abstractions over this diversity of hosting environments packaging up the best practices in loading times, memory usage and responsiveness. There is simply no way to deliver high-quality user experience without basing application development on top of these quickly evolving JavaScript frameworks such as Angular. Leave it to the smart folks in the Angular team to worry about keeping up with the evolving web application requirements while the application developers’ energies are productively engaged with solving the business problem at hand.

WaveMaker generates Angular code

WaveMaker is the only Rapid application development platform with open-standards based code generation using Angular & Spring. Our 110+ UI components are implemented as Angular components built into libraries. When the user starts building a page in WaveMaker, the product starts generating Angular code in the background. The generated code imports the UI components user dropped into the page and then wires them up using data binding.

 

The code generated by WaveMaker is fully customizable, allowing developers to write custom business logic in javascript. Using WaveMaker our customers have built line of business apps, customer-facing portals and mobile applications in several verticals such as insurance, banking, manufacturing, healthcare, retail etc.

Build full-stack teams and boost their productivity

WaveMaker offers ready to use and well-tested component library, and visual development environment to drag-n-drop these components to design a page. WaveMaker abstracts away all the Angular concepts like routing, scoping, security (auth guards), i18n and service integration with REST, SOAP & databases etc. The developer focuses on building application capabilities like user interface & interaction, representing data with widgets like Forms, Table, Lists or Charts etc., defining access control for both UI components and APIs.

Mobile-First application development

WaveMaker UI components built using Angular are device responsive and designed to suit mobile-first apps. WaveMaker platform enables hybrid mobile application development, using device-native capabilities through Cordova combined with the power of responsive Angular widgets.

Bring in existing UI components

While WaveMaker has 110+ UI components and this list is ever-growing, we realize that teams may want to build reusable UI components to further decrease the time it takes to build applications in WaveMaker. WaveMaker supports importing of reusable JavaScript components that are packaged as Angular.io elements, web components or jQuery widgets. Using a WaveMaker feature called “prefabs” existing UI components can be imported and these will stay accessible alongside the standard WaveMaker UI components and can be easily dragged and dropped onto the page that is getting developed.

Keep your application on the latest version of Angular

When users develop an app, WaveMaker generates application metadata that does not depend on a specific Angular version. From the metadata the Angular code is generated by the platform, keeping the app agnostic of any specific version of Angular. This means that the app will stay using the latest versions of Angular as WaveMaker rolls out the support for those versions. By simply upgrading WaveMaker versions the application will start reaping the benefits of staying on the latest version of Angular. There is no need to spend time in big stack upgrade projects that consumes the productivity of your team.

Build applications that load faster

One of the benefits of Angular is that the framework comes with tools that support very advanced build strategies that reduce your application’s footprint. This is very important to the application’s load time as the amount of JavaScript that is getting downloaded from the cloud uses up critical resources such as network bandwidth, device CPU. Smaller the application footprint, the faster the app loads. When you attempt to deploy the WaveMaker app, we internally use ng build –prod mode with tree shaking enabled so that each page includes only the WaveMaker UI components that it uses and not all of the library. Essentially, the WaveMaker platform takes care of all the build optimizations and keeps the application footprint as optimal as possible to give better performance and first-time load experience.

Easy to deploy onto a CDN

WaveMaker build which is triggered when the Deploy button is clicked can produce different bundles for frontend, backend code enabling the frontend code to be deployed on a CDN. Each of the resources the page depends on includes a fingerprint that represents the contents of the resource. This means that CDN that is serving static assets can be configured to set cache headers allowing browsers to cache the content and further optimizing the load times for returning users. Because of the content-based fingerprinting incremental releases of the WaveMaker application will only link to newer static assets if there was a change. In most cases, WaveMaker UI components for a page are already in the browser’s cache.

Categories
Insights

Realizing the Benefits of Containers for Rapid Application Delivery

Docker and container technology are well-known in Enterprise today. The simplified view of containers as a miniaturization of VMs seems to yield benefits of portability and faster startup times. But what is less apparent is the benefit they bring to the business. To understand this, we must first look at various scenarios in which the technology can be applied. Just as Java technology applied to IoT or Android is different from that applied to Enterprise software, the benefits realized from any technology, along with its challenges, vary depending upon the context of its application.

In this post, we’ll explore a couple of contexts in which container technology can be applied and how its benefits and challenges differ.

Containers for infrastructure optimization

This is the most common context. Here, containers are adopted by IT as a form of software packaging and distribution. Typically, IT expects to be provided with containers instead of application binaries by the development teams. So containers act as a sort of black box that contains all the software and its dependencies. Developers require to package and deliver a set of container images along with relevant configuration files–that describe how these containers may talk to each other (ports), what storage needs they have (volumes), and so on. From an IT stand-point this creates a homogenous black-box approach to deploying pretty much anything in the Enterprise, and this makes it especially suited to large, data-center scale deployments.

In this condition, the application and adoption of container technology is largely IT-oriented. It favours IT over developers as the latter need to do a lot of heavy-lifting–converting their app binaries and dependencies into container images and pushing them into a container registry. Most container management platforms out there focus on providing the right tools to IT to pull those images from a registry and provision them on a set of machines (physical or virtual). The focus of such platforms is purely on run-time aspects, such as container orchestration, with a very little context of the app or the app stack itself.

The key benefit of approaching container technology in this context is the optimization of infrastructure resource. Platforms like Kubernetes were born out of such a need to optimize infrastructure usage at very large scales (say, millions of containers). However, there are two points of caution. One, this may result in further isolation between IT and developers causing more throw-the-problem-over-the-wall scenarios. No matter how perfect the technology, experience tells us that more de-siloed communication and collaboration is the approach towards hassle-free and rapid delivery of applications in production. Hence, “DevOps”. Two, it is questionable whether all applications are suited to such a black-box hands-off approach between developers and IT. Also, the effectiveness of this approach in real usage remains to be seen.

Containers for rapid application delivery

In this case, application delivery teams adopt containers with the primary goal of speeding up the time-to-market for their apps or products. Using the rapid portability advantages of containers, development and devops engineers put together the app composition, wire together various services/ micro-services–by use of service discovery–and setup configurations for various environments. This context of container usage is more app-focused and less infrastructure-focused (though the resource optimization benefits of containers accrue over time as more apps adopt containers for delivery). Also, the approach is both design-time and run-time focused and favours development and DevOps teams over IT. It seeks to make development teams self-sufficient in getting their apps into the hands of their users.

Few platforms focus on these aspects that provide developers the required tools to automate the generation of container images, service versioning, and configuration for multiple environments of the app. The most important benefits of such platforms are rapid containerization of existing apps, rapid provisioning and configuration, and easy promotion of apps from one environment to another. Orchestration takes care of scalability and high-availability requirements, and these are configured entirely from an application perspective.

The greatest benefit for enterprises using containers for rapid application delivery is time-to-market for their apps rather than infrastructure optimization. As the market for containers matures further, expect to see a shift in focus towards this direction.

Introducing WaveMaker HyScale

Wavemaker HyScale is an app containerization and container management platform that takes the view that an application’s time-to-market is a far more important focus for Enterprise business than infra-resource optimization. The platform is built ground-up with the application in mind and every aspect is designed around the app’s stack, the app’s services, and the app’s configuration. Hence there are very few (if any) aspects of the platform that require users to deal with the underlying container technology aspects. In fact, HyScale makes it very easy for users to adopt the platform–and thereby adopt containers–without even requiring to know Docker, or use any Docker commands or even any kind of build/ deploy YAML configuration files.

HyScale allows development teams to stay focused on the app and become self-servicing at the same time, allowing them to rapidly deploy and iterate over their app.

Contact us to know more about how WaveMaker HyScale can empower your organization to achieve faster time-to-market with containers and without having to re-skill or re-tool you development workflows.

Categories
Insights

Enterprise Digital Transformation

Do not hesitate. Start from your employees.

The term, Enterprise Digital transformation, has been much maligned and misused by everyone from a consultant to a developer to a technology leader.  It has been used to describe anything from creating a website to incorporating data analytics to developing a social media strategy to just plain digitization of old paper records.   

However, a truly transformative enterprise digital experience can be achieved only when everyone in the organization feels the change.   In essence, enterprises should start their enterprise digital transformation process with their employees.

There are lot of ways you can engage your employees, but make sure you have at least accomplished the following three :

  • Emancipate your employees to kindle their innovation nerve, by sharing access to digital assets through APIs
  • Engage your employees, to ideate, collaborate and share ideas
  • Empower your employees, to give shape to their ideas through a low code app development platform

Emancipate your employees with an API management platform

Enterprise digital assets can be anything from list of all employees to list of all items procured to list of all vacation data to list of all products that the organization sells.  Not all data will be relevant to everyone.  For instance, sharing of payroll compensation data with employees will not be such a great idea.  

Sharing digital assets with external entities to promote additional revenue channel or engage customers and partners to create apps are now ubiquitous among enterprises.  Usually the digital assets are API’fied and shared with the external entities to consume.  An API Management platform is usually deployed to API’fy the digital assets, monetize using plans, and configure security and data governance policies.  Create a set of API access plans for employees and share these APIs with the employees, through a dedicated employee API portal.  

Engage your employees with a collaboration platform

We are in a digital era and having a collaboration platform within an enterprise seems to be a no-brainer.  Still there are many organizations out there with no platform to engage their employees.  There are many platforms like Slack, Yammer for your employees to collaborate and unleash their creativity.  

Engage your employees constantly, asking for their opinions on issues you are facing, announce new customer wins, conduct polls – make them feel interested and that they are wanted.  Listen to your employees, you will find some amazing idea emerging from them.  These new ideas and innovation are going to take your organization to the future.  

Empower your employees with an innovation platform

So, you have unleashed the plethora of enterprise digital assets through the API management platform and started to engage your employees through a collaboration platform.  What next? What if one of your employees has a great idea that he wants to see it materialize as an app?

Organizations should empower their employees with the fastest path from an idea to an app.  They should break the shackles of the employee and remove all hurdles – typically a dependency on technical skills and resources – to create and deploy an app from an idea.   This is what is called an Innovation-Ecosystem.

Invest in a low code app development platform that encourages employees with no technical skills to get involved, create, and go-live with an app.  Low code app development platform typically works on a visual development approach with simple drag and drop of UI components, with focus on end-user experience rather than technology.  Low code platform is the magic pill that is needed to harness the innovation potential within an enterprise.  In short, they are a new age Enterprise Innovation Platforms.   

Some of the world’s biggest business and technology disruptions started internally within an organization.  The most glaring example of that phenomenon is the Amazon AWS, which was piloted and was used as dog-food internally within the organization before it revolutionized the world with its cloud services.  It’s sort of criminal if enterprises don’t harness the innovation potential of their employees, and the best way to enable the innovation ecosystem would be to emancipate, engage and empower your employees.  Try it out for this 2017.

Categories
Insights

The three Rs of enterprise application development: Why should I pick 2?

Enterprises often struggle to strike the right balance for the investment required for various efforts in delivering applications. As businesses become more competitive, largely global, and heavily end user focused, it pushes the boundary of application requirements in order for the apps to be successful.  These requirements are usability, scalability and faster release cycles.

The landscape of application development and delivery has changed a lot in the past few years. Today’s modern applications need to look great, have a robust architecture so it can scale to millions of users, and should be quickly delivered to customers in order to outsmart competition.

The ability to deal with these three requirements has been a constant struggle for any enterprise. In any complex application project, one way or another, we face the immutable law of finite resources: We’re bound by constraints. Good, fast or cheap, we’re told. Pick any two.

This is the classic triple constraint model that you often have to deal with as project leaders. A similar model applies to enterprise application delivery:

Rich UX, Rapid Development or Robust Architecture: pick any two.

As you can see, while all these 3 things are very important for modern applications, they often work against each other. A project that focuses  only on user experience and faster time to market may not have the best robust architecture, while another one that focuses on robust architecture and great user experience may need longer duration to complete. Something has to give, right?

It used to be that businesses depending on the nature of the application could get away by just focusing on two of the above aspects,

  1.  Small and Medium Enterprise: Focus was on Rapid Development and Rich UX
  2.  Non Consumer Business Applications: Focus was on Robust Architecture, Rapid Development
  3.  Businesses that focuses on Robust Architecture and Rich UX always suffered from long lasting development cycles

Should enterprise application delivery always be an exercise in sacrifice. given the demands on IT in today’s Businesses, it has become hard to sacrifice any one of the above. So the question is how do I get to choose all.

Wait.. Hold On, can we get a magical wand that can help us have all the three dimensions of App Delivery. Look no further, modern rapid application development platforms or also referred to as low-code platforms are designed to solve this conundrum.

Take a look at WaveMaker, that specifically addresses the enterprise needs to develop scalable applications, with great user experience out of the box in shorter time frames. Excited, try out a free trial and see how you can now can now cut short development time and still keep intact your enterprise and end user requirements.

 

Categories
Insights

How RAD Platforms Can Move New App Deployment Forward

Rapid application development platforms ­– the low code and no code tools that have proliferated in the last few years – have given rise to the phenomenon of the citizen developer. A citizen developer is someone who is, or can become, proficient in RAD development, either independently or in support of a professional developer.

In the latter case, creating a new app may involve a tag-team approach in which the pro prepares the components that go into composing an app, and the citizen developer can then develop the app. Such two-pass development is one highlight of select RAD platforms.

The citizen-developer phenomenon has gained a wide following in the past few years, essentially because it enables thin IT teams to reduce their backlog of development projects. Another major reason is that citizen developers, once proficient on a RAD platform, can shelve any older development technologies they may have used.

But even with a wide following, the acceptance of RAD has not spiked in use, but instead has evolved from quick and dirty apps (which were more like prototypes) to nice and final apps (offering a great user experience).

As part of that evolution, a number of use cases for RAD emerged. Arguably, the most popular of those are:

  • Live data forms that are used to create form-based line of business applications with the ability to do CRUD, sorting, caching and loading of data.
  • Prototyping to create working prototypes from application mock-ups to quickly build real-life working prototypes of concepts and wireframes and shorten feedback cycles on application development.
  • Application modernization to allow existing legacy applications to deliver more responsive, modern user experiences while keeping the backend data source and business logic intact.
  • Business dashboards that rely on apps that fetch data from multiple data sources (databases, APIs, custom business logic, files, legacy apps, cloud services, etc.) to populate them and provide access to critical business data.
  • API-driven applications that enable organizations to create greater flexibility in IT application infrastructure by moving away from three-tier applications to smaller, independent microservices-based applications.

RAD platforms are not best suited for developing gaming or other highly interactive apps that use very little data. That would rule out Uber-like apps and gaming apps such as Angry Birds.

RAD is most suitable when the apps are data-driven, often populated from a database system. Pagination of data or memory management (for example, a mobile app that brings in too much data ahead of use may waste data traffic; whereas one that brings in too little could provide poor interactivity) is very tricky particularly when apps need to use AJAX. AJAX is a very common form of programming, for both web and mobile apps, where data is fetched on demand. AJAX applications – also called single-page applications, because data is called into a page without need for a server fetch of a new page – provide a better user experience and are hence preferred.

In addition, low-code platforms are well suited for those applications that are created in Gartner’s Pace Layers model: Systems of Innovation or Systems of Differentiation. Low-code platforms are also suitable for Mode-2 development (the Innovate layer), as defined in Gartner’s Bimodal IT model.

As we see a rampant spread of the consumerization of IT (i.e., corporate apps that look and act like consumer apps), RAD is seeing a new growth phase.

The D in RAD has also been redefined in the new era. Today, the D in RAD refers to both delivery and development. RAD platforms have evolved to cover the entire breadth of application delivery. For instance, some RAD platforms combine a developer cloud to reduce cycle times further (test-as-you-build) and increase productivity. This also makes it simpler to move an app from the developer environment to staging or production (for example, through use of containerization technology).

In short, today’s RAD platforms are nothing like their earlier cousins, although the goal of rapidity still remains.

The challenges of traditional development are not new, nor have there been any substantive improvements in traditional languages that would deliver quantum improvement in time to deployment of new apps – where speed virtually always means corporate cost savings, earlier opportunities for app monetization, or both. That dearth of innovation virtually opened the door for a surge in RAD adoption, whether it resulted from need or opportunity.

Originally published by Vijay Pullur, CEO of WaveMaker, in tmcnet.com

Categories
Insights

Predictions for low code development using RAD platforms!

It’s that time of the year!!  Predictions for Low Code Development using RAD Platforms.
First of all wishing everyone a great new year and all the success for your products, services, customers and partners! It is that time of the year, where many in the technology industry spend time penning down predictions on the future of technology and everything revolving around it.  In the past few days, I have read various predictions on technology, tech marketing, sales enablement, tech disruptions, Cyber Security, and the list goes on and on…
I thought to contribute one more prediction to the many, out there.
This blog is my personal take on what 2017 will look for the RAD (Rapid Application Development) and more specifically trends within Applications developed using such an approach. This is based on my experiences working with customers, partners, speaking to folks in this industry and general analysis of the market trends.

Adoption

  • More Enterprises will continue to invest heavily in searching, exploring and concept proofing RAD for their own development needs.
  • RAD will move from experimental discussion to a serious topic of discussion and consideration among architects, development leaders and application influencers within enterprises as a way to increase productivity to develop Applications.
  • While RAD and low code development platforms came to being to democratize app development and continue to do so, we will see more of professional application developers join the bandwagon of using RAD platforms as a way to develop sophisticated enterprise applications.

Scope of RAD Platforms

  • RAD vendors will evolve from only development to full-fledged development, deployment and application hosting platforms
  •  As professional developers get deeply involved with RAD, they will want to bring in best practices in app development, deployment and DevOps from their vast experiences into application lifecycle. They will push the borders of RAD to increase its scope to include features around DevOps integration, code Branching, automated testing, cloud deployment, real time integration etc.
  • IoT platform integration will emerge as a key use for applications.

Ease of Development
RAD platforms will be expected to provide drag and drop out of box packaged integrations to commonly used services (Payment Gateways, SaaS Platforms, Identity Services, Cloud Services etc). As part of this, API based integration will become a de facto way to develop applications and integrate with internal as well as external systems.        

Ecosystem Play
For enterprises to fully utilize the power of RAD platforms, they will start to coexist RAD with other complementary platforms in the overall App Ecosystem.

  • RAD and API Management Platforms complement each other. These two platforms can feed off each other. RAD can help solve the last mile problem of easy app development for API management platforms. RAD can help create the APIs for App management platforms.
  • With IoT gaining traction, RAD and IoT platforms will gain more traction in this year.
  • SaaS Platforms will use RAD as an effective way to increase developer adoption and ecosystem creation.

Hope this prediction list has been interesting. Let’s see how 2017 pans out for RAD / Low  Code Platforms. While I am not a fortune-teller and do not intend to be one, and guarantee the above predictions, there is one thing I can guarantee, that the ride will be exciting for  RAD platform vendors as well as enterprises that adopt it. So stay tuned and let’s see how this unfolds itself.

Categories
Insights

Modern RAD for Modern Enterprise Applications

The age-old problem chasing Enterprise IT custom application software development is the inability to deliver applications on time and at the speed with which business demands. Some stats here will validate this:

One in six projects have a cost overrun of 200%, on average, and a schedule overrun of almost 70%. Source: HBR Study

75% of business and IT executives anticipate their software projects will fail. Source: Geneca Study

Enterprises over the years have been dealing with some key challenges not limited to, complexity in dealing with technology stacks, lack of faster approaches to application development, lack of business user participation through the lifecycle, lack of on-demand infrastructure readiness etc.

Another major complaint of employees is the lack of usability and user experience design of enterprise applications. Former NYTimes.com Design Director Khoi Vinh captured this common frustration in his seminal 2007 article.

If it looks like a cow, swims like a dolphin and quacks like a duck, It must be Enterprise Software

Now let us take a step back and talk about how we solve this enterprise conundrum of developing custom applications at rapid pace with good-looking user experience and with enterprise standards. To do this, let us understand a concept called Rapid Application Development and its history.

What is Rapid Application Development?

A system development approach that employs tools, techniques, and methodologies designed to speed application development. Source: Fundamentals of Information Systems 7th Edition by Ralph Stair and George Reynolds

RAD tools have been around since the late 80’s. Multiple attempts have been made to improve application development productivity. Historically, the key focus of these tools was mostly just on code generation. Developers still had to worry about app infrastructure, code openness and extensibility, application integration plumbing, hosting, and monitoring of apps. While these tools helped in developer productivity, it came short of fulfilling the enterprise desire to create applications that are rich in user experiences.

Era of Consumerization

The consumerization of IT has raised the bar with respect to User Experience and Usability. Enterprises are expected to carry over the learnings from the consumer world and pay high attention to this. We have witnessed the emergence of these technologies that has fundamentally shaped the nature of computing. These include and are not limited to, user-centered design, cloud computing, Web APIs, Enterprise mobility, Client-Side Development Frameworks, and Continuous delivery.

So the next logical question is can we combine the modern technological innovations and RAD together to provide a wholesome platform to Enterprises looking to develop modern user-centric responsive custom web applications at speeds that can match business expectations.

This is the emergence of what I call Modern RAD (Modern Rapid Application Delivery) platforms.

What do Modern RAD platforms offer?

Modern RAD not only focuses on reducing application development timelines, but also addresses a whole slew of other related aspects of modern web applications required for today’s modern enterprise. Modern RAD emphasizes on:

  • Ready-made Application Infrastructure: Providing a browser based development environment. No more hassle of installing, setup, ongoing configuration etc.
  • Usability: Making sure good-looking and rich user interactive applications can be developed. Increased attention to creating pixel perfect responsive UI applications on both Desktop as well as Mobile Devices.
  • Full Stack Development: By leveraging modern client side frameworks and server side technologies, Modern RAD is now capable to auto generate code for the entire application (client side, Server side as well as integration touchpoints to external systems and services via APIs).
  • Pre-Defined Best of Breed Technology Stack: Providing a pre-defined well tested best of breed of software components as the technology stack for application development. No more worries about enterprises having to maintain multiple teams to support complex permutations of technology stacks.
  • Business User Participation: Simplifying the application development process such that technical business users can work together with professional developers in developing the application. This greatly benefits enterprises as business user comes in with domain knowledge and can validate the implementation, as it is being developed.
  • API-led Integration: Providing REST API-based integration approach such that application can easily integrate to an internal, external as well as Cloud-based service. This allows for faster, easier development and avoids reinventing the wheel again.
    and  finally one more important thing,
  • Displace Stigma attached to RAD: There is a stigma attached to using RAD platforms. “How good is the application created using RAD, as compared to a self-developed one?” Scalability, Security, Extensibility, Maintainability, Enterprise Architecture, Modularity of generated Code get questioned. Modern RAD this time around, also lays a great emphasis on this. In addition to features that help increase develop productivity, these items are addressed at greater degree to comfort Enterprises in adopting and deploying at large scale.

Is Modern Rapid Application Development the answer to the problems that plague today’s Enterprise IT? Or is it too good to be true? What do you think?

You can also watch the recorded videos of our Webinar Modern RAD – Too good to be true?, where we have discussed modern RAD and evaluate its potential for enterprises to cope with rapidly evolving business demands.

Categories
Enterprise Application Development

WaveMaker Prefabs – A Primer

What are Prefabs?
In WaveMaker Studio, you would have noticed this unassuming group of components that are stashed in the Design-Toolbox accordion and contains components like Youtube, Google-Maps and Fbpost under it.(Fig-1).  These group of widgets are called Prefabs.

But what are they?  What’s their purpose of existence? These are exactly the kind of questions that we will try to answer in this post.

At a very basic level,  Prefab is nothing but an application.  Like an application, you can develop, test and deploy these Prefabs independently.  User can stack up a group of Prefabs and build a new app.  Prefabs typically represent a small independent logical business need of the enterprise app (a micro app).  For example, an Event Management Prefab.


How are Prefabs structured?
Structurally a Prefab is like any other WaveMaker app containing a UI layer for presentation, a backend layer representing the business logic and a REST API layer between them for communication.  (see Fig-2)

For example, the Fbpost Prefab, provided by default in WaveMaker Studio,  has a UI layer, wherein it accepts inputs from the user to post a message into the user’s Facebook wall, passes on these user inputs through REST APIs to the backend business logic, which communicates with the Facebook server to post the message.

Prefabs fosters the concept of reuse

I have already explained how Prefabs are just micro-applications that can represent an independent business logic like Event-Management.  But in explaining that one important point would have got lost, if not for this section on reuse.  This Event-Management Prefab once created can be re-used across any apps within an enterprise.  This concept of REUSE is a very powerful one and is often not given its due share of importance in an application building process.

Prefabs abstract API consumption complexity
Prefabs are essential tools in abstracting the complexity associated with API consumption and saving a lot of time.  Business developers in an enterprise usually find it difficult to understand the intricacies of the APIs because of the technical nature of its existence.  In the example above, instead of using a Fb post Prefab, if the user had to directly work with the Facebook APIs, then that immediately increases the complexity associated with the task manifold.  API complexities range from understanding technologies like OAUTH for authentication to understanding the semantics associated with APIs themselves.  But what if these complexities are abstracted and presented as simple intuitive UI components? …that is exactly what a Prefab does.  Of course, there is a one-time effort in creating the Prefab itself, but WaveMaker envisions an app and Prefab marketplace where these common utility Prefabs can be just got out of the box and integrated into the app.

Prefabs to assemble your apps
Composable Enterprise, a concept where the applications are built based on the composition of decoupled services to achieve higher levels of agility, is a concept that is gaining prominence.  You can learn more about the composable enterprise model in this blog written by Jonathan Murray, EVP and Chief Technology Officer of Warner Music Group.  WaveMaker uses a Prefab to ease the process of building composable apps.

In WaveMaker, Prefabs are used like any other UI widget.  All that user has to do is drag and drop these Prefabs onto the canvas.  Prefabs use their REST API layer to communicate with the parent app (see Fig-3).  Applications can be built as stackable layers of Prefabs.

And finally, when an application gets deployed, WaveMaker resolves all the Prefab dependencies of the app and deploys the app as one single component into a Docker container as shown in Fig-4.

All the REST APIs in the Prefab can also be published for sharing and consumption by other apps.  This is similar to the design and sharing of APIs in an app and is done using API Designer.  If you are interested you can read my earlier blog post that talks about the capabilities of the API designer in detail.

Prefabs to integrate 3rd party widgets
Prefabs are powerful tools for extending the capabilities of the WaveMaker Studio.  Whenever the developer feels that a particular widget, available externally,  is not available natively in the WaveMaker Studio library, he or she can immediately integrate that external 3rd party widget into WaveMaker Studio library using Prefabs.  Prefabs in a way extend the capabilities of the studio through this approach.  In one of my earlier blogs, I had explained in detail how you can integrate an external 3rd party Jquery widget.

Prefabs as Microservices [#]
Microservices (MSA) is a new (yet another!) software development architecture, which is gaining prominence.  In this approach, a bigger app is built as a composition of small decoupled services, called Microservices, which typically represents an independent business need.  These micro-apps are connected together by APIs (primarily HTTP/REST APIs) to build a bigger app.  These Microservices also have technical characteristics that include independent testability, deployability, and upgradeability. For a more detailed explanation of MSA, you can check out Martin Fowler’s article on Microservices here.

By now you would have noticed that Prefabs perfectly fit into the definition of a Microservice as defined above, word for word. As WaveMaker takes its next step into the future to enable Microservice-based apps, Prefabs will play a significant role to ease the process of creating and deploying MSA-based apps.

Check out the sample reference architecture (Fig-5) of an MSA app created using WaveMaker and Prefabs deployed into separate Docker containers in WaveMaker Cloud platform.

Prefabs ecosystem [#]
Prefab is a great utility for achieving modularity, reusability, and abstracting complexity in WaveMaker,  but it’s not free lunch either.  There is a one-time effort that is involved in creating a Prefab before the user and the enterprise can reap its benefits.  But to even reduce this one-time creation step, a simple effective utility, which has revolutionized the way in which people consume services in this digital world, can be used.  This utility is called a MarketPlace or an AppStore.  Once an ecosystem of the commonly used Prefabs and apps is established, the consumption of these Prefabs will be as easy as discovering the Prefabs in the AppStore and integrating it into your app.

Check out the below image that captures the overall prefabs usage succinctly.

Prefabs can be quite a powerful tool if used strategically and can make the concept of composable enterprise come true very easily.  Excited to try Prefabs? Create your WaveMaker app now!

Key
[#] – Planned for future releases

Categories
Enterprise Application Development

Import data from MS-Excel documents into WaveMaker

Microsoft Excel is the most widely used spreadsheet application around the globe and in this post we will see how to import data from an Excel file into a grid widget of WaveMaker Studio.  For reading the Excel file we will be using Apache POI libraries.

Scope of this blog

  1. We will be creating a Prefab to upload an Excel file and display it using the grid widget in an application.
  2. The Excel file is assumed to have a particular structure with a heading in its top row as shown below.
  3. This post covers only the basic Excel integration, restricted to the reading and displaying the spreadsheet data in a grid widget.  We use a Java service for reading the Excel file.
  4. By modifying the provided Java service, one can implement more complex Excel integration using Apache POI libraries and methods.

Steps involved in WaveMaker-Excel integrations:

  1. Download the latest version of Apache POI library from HERE.
  2. Create a new “Prefab” Project.  I call it ReadWriteExcel (though I just demonstrate only Excel reading 🙂 ).  I will have another post for exporting Excel documents in the future.
    1. Import the following jars into WaveMaker
      Note: The JAR names could be different depending on the POI release you had downloaded.  I had downloaded Apache POI 3.11.

      1. poi-3.11-20141221.jar
      2. poi-ooxml-3.11-20141221.jar
      3. poi-ooxml-schemas-3.11-20141221.jar
      4. commons-codec-1.9.jar  (in $POI_HOME/lib directory)
      5. xmlbeans-2.6.0.jar (in $POI_HOME/ooxml-lib directory)
    2. Create a Java Service (I call it XLSReaderWriter). This java service uses the APIs provided by the Apache POI libraries, reads the excel file and outputs the content as a JSON object.  The Java service code is given below..
      /*Copyright (c) 2015-2016 wavemaker-com All Rights Reserved.This software is the confidential and proprietary information of wavemaker-com You shall not disclose such Confidential Information and shall use it only in accordance with the terms of the source code license agreement you entered into with wavemaker-com*/
      
      package com.readwriteexcel.xlsxreaderwriter;
      
      import com.wavemaker.runtime.javaservice.JavaServiceSuperClass;
      import com.wavemaker.runtime.service.annotations.ExposeToClient;
      
      
      import java.io.InputStream; 
      import java.io.FileNotFoundException;
      import java.io.IOException; 
      import java.util.Iterator;
      import java.util.*; 
      
      import org.apache.poi.ss.usermodel.Cell;
      import org.apache.poi.ss.usermodel.Row;
      import org.apache.poi.ss.usermodel.Workbook;
      import org.apache.poi.ss.usermodel.Sheet;
      
      import org.json.JSONArray;
      import org.json.JSONObject;
      import org.json.JSONException;
      
      import org.springframework.beans.factory.annotation.Autowired;
      import com.wavemaker.runtime.server.upload.FileUploadDownload;
      import com.wavemaker.runtime.server.*;
      import org.apache.poi.ss.usermodel.WorkbookFactory;
      import com.wavemaker.runtime.*;
      import javax.servlet.http.*;
      
      /**
       * This is a client-facing service class.  All
       * public methods will be exposed to the client.  Their return
       * values and parameters will be passed to the client or taken
       * from the client, respectively.  This will be a singleton
       * instance, shared between all requests. 
       * 
       * To log, call the superclass method log(LOG_LEVEL, String) or log(LOG_LEVEL, String, Exception).
       * LOG_LEVEL is one of FATAL, ERROR, WARN, INFO and DEBUG to modify your log level.
       * For info on these levels, look for tomcat/log4j documentation
       */
      @ExposeToClient
      public class XLSXReaderWriter extends JavaServiceSuperClass {
          @Autowired
          FileUploadDownload fileUpload;
      
          /* Pass in one of FATAL, ERROR, WARN,  INFO and DEBUG to modify your log level;
           *  recommend changing this to FATAL or ERROR before deploying.  For info on these levels, look for tomcat/log4j documentation
           */
          public XLSXReaderWriter() {
             super(INFO);
          }
      
          public void readExcel(String fileName, HttpServletResponse response ) {
              String resultString = null;
              Workbook book = null;
              InputStream fis = null;
              try {
      
                  log(INFO, "inside readExcel"); 
                  
                  DownloadResponse dresponse = fileUpload.downloadFile(fileName,fileName);
                  fis = dresponse.getContents();
                  
                  book = WorkbookFactory.create(fis);
                  Sheet sheet = book.getSheetAt(0);
                  
      			// Start constructing JSON.
      			JSONObject json = new JSONObject();
      			
                  Iterator<Row> itr = sheet.iterator();
      
      			// Iterate through the rows.
      			JSONArray rows = new JSONArray();
      
                  // Iterating over Excel file in Java
      			int rowCount = 0;
      			ArrayList<String> headerList = new ArrayList<String>();
                  while (itr.hasNext()) {
                      Row row = itr.next();
      				JSONObject jRow = new JSONObject();
                      log(INFO, "inside row iterator");
      				// Iterate through the cells.
                      // Iterating over each column of Excel file
                      Iterator<Cell> cellIterator = row.cellIterator();
                      int cellCount = 0;
      				while (cellIterator.hasNext()) {
                          log(INFO, "inside cell iterator");
      
                          Cell cell = cellIterator.next();
                          JSONObject jCellObj = new JSONObject();
                          switch (cell.getCellType()) {
                          case Cell.CELL_TYPE_STRING:
      						if(rowCount == 0) 
      							headerList.add(cell.getStringCellValue());
      						else{
      							jRow.put((String)headerList.get(cellCount),cell.getStringCellValue()); 
      							log(INFO,cell.getStringCellValue() + "t");
      						}
                              break;
                          case Cell.CELL_TYPE_NUMERIC:
      						jRow.put((String)headerList.get(cellCount),cell.getNumericCellValue()); 
      						log(INFO,cell.getNumericCellValue() + "t");
                              break;
                          case Cell.CELL_TYPE_BOOLEAN:
      						jRow.put((String)headerList.get(cellCount),cell.getBooleanCellValue()); 
      						log(INFO,cell.getBooleanCellValue() + "t");
                              break;
                          default:
                              jRow.put((String)headerList.get(cellCount),""); 
          
                          }
      					cellCount++;
                      }
      				if(rowCount == 0) {
      					rowCount++;
      					continue;
      				}
      				rows.put( jRow );
                      
                  }
      	        // Get the JSON text.
      	        resultString = rows.toString();
      			response.setContentType("application/json");
      			response.getOutputStream().write(resultString.getBytes("UTF-8"));
      			response.getOutputStream().flush();
          
              } catch (FileNotFoundException fe) {
                  fe.printStackTrace();
                  log(ERROR, "The sample java service operation has failed", fe);
              } catch (IOException ie) {
                  ie.printStackTrace();
                  log(ERROR, "The sample java service operation has failed", ie);
              } catch (JSONException je) {
                  je.printStackTrace();
                  log(ERROR, "The sample java service operation has failed", je);
              } catch (Exception ex) {
                  ex.printStackTrace();
                  log(ERROR, "The sample java service operation has failed", ex);
              }finally{
                  try{
                      if(book != null){
                      book.close();
                      }
                      if(fis != null){
                        fis.close();
                      }
                      
                  }catch(IOException e){
                      //swallow this
                  }
              }
              
      		
          }    
      
      
      }
      
    3. Design UI to consume the JSON object from the java service and show it as a grid.
      1. Use the File upload widget to allow user to select the excel file.  I call it “Select File & Load Grid”
        Select the required upload directory.  The file will be saved in this directory in runtime.  You can check out the uploaded file “Employee.xlsx” – in the /resources/uploads directory after using the file-upload widget in runtime.
      2. Edit the java service variable (XLSReaderWriterReadExcel) and bind the filename variable to the filename from the file upload widget, as shown below. Also, make sure to enable the “Auto Update” property for this variable
      3. Drag and drop a  grid and bind it to the Java service variable created from the previous step.(i.e. XLSReaderWriterReadExcel)
    4. This is a fully functional Prefab and can be tested like any other application. Go ahead, run the application, and test it.
    5. Export prefab as a zip file, to use it in various applications.
  3. You can use this prefab in any other project by importing the prefab zip file into any project.  Try it out.
Categories
Enterprise Application Development

Making RAD good for developers

Rapid Application Development (RAD) tools and platforms offer agility and enable development teams to jump start quickly onto a Project. Use of RAD methodology reduce the time and effort required to:
a) evaluate the technology stack and frameworks
b) design and implement boiler-plate CRUD code, SQL queries and UI-based forms
c) prototype and test with production data very quickly

In the past, the code generated by RAD tools in comparison with hand-written code was considered to be not readable, not maintainable and believed to offer very less customizations and abstractions. However, frameworks and technology stacks have matured over time, moving a lot of heavy lifting from developers and offering better tooling support. With the current generation RAD tools and platforms leveraging modern technology stacks, there is no noticeable difference between generated code and hand-written code.

WaveMaker Studio incorporates advanced code generation techniques with the right abstractions and design patterns, rather than generating code that just works. WaveMaker Studio provides niche application architecture by standardizing on open-source Application Stack, using some of the best-of-the-breed libraries like Spring, Angular, Hibernate and Bootstrap. Open standards application stack enables developers to freely distribute and modify the generated source code and doesn’t have any vendor lock-ins into the platform.

No platform lock-ins for built applications

While most of the Rapid Application Development platforms tend to lock in applications within their own platform, like Force.com, BlueMix, or Mendix, WaveMaker takes a radically different approach to use open-standards-based generated code and 3rd party services integration through plug-n-play REST API based contracts. Developers have the liberty of moving the application built from the platform and deploying in their own custom infrastructure.

Code generation with no trade-offs in design or performance

Angular JS library, built and maintained by Google, came into mainstream adoption only in recent years. Angular is the key driver for WaveMaker front-end code generation, leveraging the abstractions provided by the framework to generate dynamic client-side application logic. Generated code extensively uses Angular concepts such as directives, re-usable components, data binding, routing, and form validation.

Let us build a CRUD-based application to take a closer look at WaveMaker Studio-generated code for front-end and back-end artifacts. The following Fig 2. shows a simple application page design with separate sections for header, left navigation, and content.

Well designed and organized front-end artifacts

The content section has a 2-row grid layout, each row having a different number of columns and widgets placed within. Following Fig 3. Shows the code generated by WaveMaker Studio for the above web page design.

The generated markup has separate sections for header, topnav, leftnav & content area, and for each widget, its corresponding Angular directive gets generated. WaveMaker provides a comprehensive Angular-based open-source widget library, and the documentation is available here.

For each designed web page, a well-organized set of artifacts are generated for HTML, Javascript, Stylesheet & property files for variables defined within the scope of the page. Any event handling code or custom client-side logic should be written in the page-specific javascript file and the HTML markup can be edited directly by using the appropriate widget directive syntax.

Extending and customizing generated code

To control the interaction between widgets and variables (service, live, java, etc.), custom javascript code may need to be written in the javascript file generated for each page. For example, to enable navigation to a new page after submitting form data, custom javascript needs to be written for the onSuccess event of a live form.

The following example has a snippet of code, which uses custom javascript code to bind data provided through one widget as input to another widget or prefab. WaveMaker Studio’s javascript editor provides code completion and IntelliSense features to search and identify the available bindings within the scope.

Design thinking and Model-driven development (MDD) paradigm

WaveMaker Studio-built application’s back-end architecture leverages Spring framework and Hibernate for persistence.

Fig 6a. Spring framework-based architecture, Fig 6b. Spring-based backend code generation

Spring framework is widely used by Java developers and offers a very flexible architecture, extensible, and provides cleaner abstraction. WaveMaker Studio provides the right balance between generated code and any runtime libraries used, giving maximum control to the developer to customize and change the generated code.

Studio generates the following artifacts for application back-end:
1. Model Objects – Domain model objects are POJOs with standard JPA annotations
2. Services – CRUD operations and other business logic for model objects
3. Controllers – Spring REST web service controller

WaveMaker Studio adopts model-driven development (MDD) methodology, by importing from existing database schema or allowing the developer to first design database schema using the database designer. After successfully importing the schema, for each database table, domain model objects and their corresponding services and controllers are generated. If there are any changes to the database schema, code is re-generated.

In the design mode, Studio supports hot deployment of changes and completely relieves developers from compilation and code-generation aspects. Internally, Studio uses the Maven-based application build process, which makes the necessary application runtime dependencies to be included in the POM file and provides an option to export the entire Studio-built application as Maven project.

Designing the domain model

WaveMaker Studio provides a very comprehensive domain model or schema designer, which supports dialect mappings to the underneath database and provides modeling the relationships as well.

Domain model objects are auto-generated from the database schema, with JPA annotations and respective database mappings. Getter and Setters are auto-generated with the corresponding column mappings, relationship, and join column mappings. Domain model objects are plain POJOs without any dependency on the WaveMaker runtime library.

Separation of layers for extensibility and integration

Domain model, service, and controller layers are separated out in the generated code for extensibility and readability. For every domain model object, a Service class is generated, which provides CRUD operations and query execution with complete support for pagination, query filters, etc. Service class depends on WaveMaker runtime library, which is open source and provides the persistence runtime logic based on Hibernate.

API-centric approach as a first step to application design

For every domain model object, web service controller is generated based on Spring REST, with appropriate path mappings. For database services, REST controller exposes CRUD operations and query execution methods automatically and the visibility of these APIs can be configured through API designer.

Summary

WaveMaker Studio-generated code incorporates the best practices followed by professional Java or Javascript developers and guarantees the best code quality, maintainability, and extensibility for enterprise application use. With most of the application back-end code being auto-generated, developers can now focus more on User experience, custom business logic, and any other 3rd party integrations.

In a follow-up post, we’ll discuss the extensions provided from an application developer’s perspective for customization and tweaking the generated code. We will discuss details related to form validation, styles and themes, Spring bean customization and application security integration. Stay Tuned!