A few weeks ago, JourneyApps officially launched OXIDE, our next-generation IDE. As part of the launch, we have been exploring the “dreams versus reality” of low-code, and showing how the industry can chart a more enlightened course for software development. This is part 4 of the series. You can read part 1 here, part 2 here, and part 3 here.
In part 1 and part 2 of our series, we showed how to look beyond the hype of no-code/low-code platforms — how you can tell when low-code/no-code platforms are not the right tool for the job, and when to use code instead. Then, in part 3 of our series, we went through the 10 questions you should ask to properly evaluate the pros and cons of platforms that enable high-productivity app development using code.
In part 4 of our series, we will put JourneyApps to the test using the evaluation framework from part 3. We will show how JourneyApps avoids many of the pitfalls of both no-code/low-code platforms and pro-code development tools, and thereby ushers in a new paradigm of app that development that offers the “best of both worlds”: Ultra high-productivity, yet code-centric, based on open technologies.
High-Productivity App Development Using Code: How Does JourneyApps Stack Up?
When it comes to evaluating platforms that combine visual app development with writing code, there are 10 critical questions that you need to ask. Let’s go through these 10 questions for the JourneyApps platform:
1. Is code a first-class citizen or an afterthought behind visual tooling?
In part 3, we said:
When a high-productivity app development platform allows you to use code as the primary mechanism for building apps, and development productivity has been streamlined around writing code, this is a good sign if you’re planning on building ambitious and sophisticated apps. When code is an afterthought that was added on top of a primary visual drag-and-drop low-code tool, it generally tends to perform much more poorly. It’s often very complex and convoluted, and switching to code means that your development velocity often slows down dramatically.
In JourneyApps, code is a first-class citizen for developing apps, and it’s complemented by visual tools. Compared to no-code/low-code platforms, the benefit of being code-centric is that JourneyApps can handle extremely complex use cases that require advanced logic, computations and algorithms, and highly customized integrations.
Also, because code is a first-class citizen in JourneyApps, we put a lot of thought into it. We spent years of R&D around the challenge of reducing the complexity and effort required of building applications using code. As a result, JourneyApps provides developers with incredible leverage and productivity — eliminating a huge swath of the traditional complexity associated with building apps using code.
- The platform has a series of powerful abstractions built-in. For example, developers do not have to worry about things like authentication, state management, 4-way data binding, 80% of UI behavior, network calls, cross-platform compatibility & responsiveness, and a whole host of other concepts.
- The platform has a huge collection of extremely powerful built-in functionality that can be used by the developer with minimal configuration and/or code. For example, JourneyApps has the most advanced relational bi-directional offline data sync on the market, and it can instantly be used in any app with zero configuration.
- We created the most powerful web IDE to hit the market yet: OXIDE, which includes a plethora of developer productivity features, including IntelliSense, extensive automated code validations, live co-editing, and GitHub integration.
Visual tools are used in the platform in areas where they are most appropriate and impactful. For example, user interface layouts can be built using either visual drag-and-drop tools, or code. The same goes for defining relational data models.
2. What is the skill level required to build apps on the platform using code?
In part 3, we wrote:
If we look at the major low-code platforms that offer “pro-code extensibility”, the code that developers have to write tends to be very complex and requires expertise in compiled languages such as Java and C# that are typically used in enterprise software environments. This typically translates to hiring senior developers who are familiar with these languages — which means that you often spend more money on staff, and have to beat out your competitors in hiring scarce developer talent.
By contrast, developers can build apps in JourneyApps using JavaScript or TypeScript. The use of popular and easy-to-learn languages, combined with the elimination of complexity from coding, means that developers of all skill and experience levels can be productive on JourneyApps.
A junior JavaScript developer with minimal experience can hit the ground running with building full-stack custom applications within a day. Technically-minded folks who have written their own Macros in Excel also consistently become proficient in the platform in under a week.
3. What is the learning curve for the platform?
In part 3, we wrote:
Platforms that are based primarily on visual development tools tend to be highly proprietary. Even if they offer pro-code extensibility, the bindings, APIs, and patterns that need to be used in the code also tend to be highly proprietary.
By contrast, JourneyApps avoids proprietary technologies and concepts as far as possible. JavaScript and TypeScript are the languages used for logic. Building apps is based on the straightforward Model-View-Controller approach. To define view layouts and data models, an intuitive point-and-click visual interface is provided – or developers can also opt to edit the code directly, using a simple XML syntax. Developers can write server-side logic using the CloudCode serverless computing engine, which is a standard Node.js environment.
This is why a junior JavaScript developer can become productive in the platform on their first day.
4. Is coding on the platform based on a popular, open language?
In part 3, we mentioned:
Some code-centric app development platforms require developers to use proprietary languages such as 4GLs to develop apps. Visual LANSA, for example, requires developers to use its RDML language.
By contrast, building apps on JourneyApps uses JavaScript or TypeScript. JavaScript is the most popular programming language in the world. TypeScript is a statically typed version of JavaScript, and is one of the fastest-growing languages in the world, with strong advantages over plain JavaScript.
5. Can you make use of open source libraries, or are you stuck in a walled garden?
In part 3, we said:
Some low-code app platforms don’t allow you to use any of your own software libraries, because of their proprietary nature. Some of the big low-code platform vendors offer their own “app stores” where you can get widgets and components from a closed community. This can often mean that your innovation is at the mercy of the vendor and its closed community.
By contrast, JourneyApps allows extensibility on both the front-end and back-end.
- On the front-end, custom UI components can be built using HTML and any JavaScript libraries.
- On the backend, the CloudCode environment built into JourneyApps is a Node.js environment which allows developers to include any NPM packages. NPM is the largest software package registry in the world, with more than a million open-source software packages.
6. Developer productivity: What kind of headcount do you need?
In part 3, we said:
Many low-code platforms that are extensible with code leave a massive amount of heavy lifting to the developer. The developer often has to write thousands of lines of code to implement certain kinds of functionality. A common example that we’ve seen is data synchronization. OutSystems provides some tooling for offline data sync, but the developer has to do much of the heavy lifting themselves — writing their own sync logic. With Ionic, developers also have to write their own SQLite queries to implement offline functionality. Requiring developers to do this pro-code level coding to implement this kind of functionality means that you need a larger headcount of more expensive senior developers. It also means that projects take more time, and there is more technical risk involved.
By contrast, the built-in features in JourneyApps give developers an incredible degree of leverage. Some of the key examples are:
- JourneyApps has the most advanced relational bi-directional offline data sync on the market, and it can instantly be used in any app with zero lines of code.
- JourneyApps has the most powerful data grids / object tables on the market, with features that rival that of Excel, including sorting, filtering, frozen columns & rows, copying & pasting, direct editing of data in cells, keyboard shorts, and more. Developers can build an app with all of these features with a few dozen lines of code.
7. Is the platform a true full stack, or do you need to build your own full stack?
In part 3, we wrote:
Many of the major app development platforms on the market do not provide a true full stack. With most of them, you have to bring your own database. Many do not even provide a cloud backend at all. This means a much higher total cost of ownership (TCO) since you have to wire together and maintain the full stack yourself. There is also more technical risk in putting together your own stack
By contrast, JourneyApps provides a full stack, that is actually turn-key. In a few hours, you can go from logging into the platform for the first time, to having a secure, real app that runs on any device (desktop/smartphone/tablet, iOS/Android/Windows/macOS/Linux and web), syncing data with a cloud database, with custom server-side logic. All without adding any additional 3rd party components — just the JourneyApps platform.
8. How badly are you locked in to the vendor?
In part 3, we mentioned:
Vendor lock-in is a major drawback of many low-code platforms. In many cases, the platforms have no portability — you either can’t export your code out of the platform, or the code which you’re able to export is virtually unusable.
By contrast, developers write JavaScript (or TypeScript) and XML code in JourneyApps, and they can export it at any time. In fact, JourneyApps comes with built-in GitHub integration, so you can store your source code outside of the platform in your own hosted Git repository.
In the rare cases where customers wanted to move an app off the JourneyApps platform, they were able to take their business logic code and reuse it on another tech stack with relatively light refactoring.
9. Are developers excited about using the platform?
In part 3, we said:
Professional software engineers tend to loathe low-code platforms. As the folks behind the open-source framework Ionic put it: “Low-code presents a fundamental threat to your relationship with your developers”.
By contrast, since JourneyApps is based on open-source languages and technologies such as JavaScript, TypeScript, Node.js and NPM, it is a very developer-friendly environment. Code is a first-class citizen in the platform, and JourneyApps offers a desktop-grade IDE (our OXIDE web IDE) all the advanced features that developers typically love to have in their IDE.
- Image: Wikimedia Commons. Manfred Werner - CC by-sa 4.0
10. How much does the platform reduce your risk?
In part 3, we wrote:
When you’re evaluating app development platforms and are thinking through all the above questions, we encourage you to analyze what it means for your overall risk profile. You may be surprised at how much risk you’re willing to take on if you accept many of the unpleasant trade-offs of low-code platforms.
Given all the aspects that we explored above, it is clear that JourneyApps keeps risk as low as possible in custom software development.
- Being code-centric instead of no-code reduces the risk of running into serious limitations.
- Relying on open source languages that are highly popular with readily available developer talent reduces risk as much as possible.
- Extensibility using open software package repositories reduces risk.
- Easily being able to export code, thereby avoiding typical vendor lock-in risk, reduces overall risk.
- Not requiring hand-coding of functionality like offline data sync reduces technical implementation risk.
- A smaller learning curve and lower need for developer headcount reduces risk (due to lower costs involved).
What Does All Of This Mean For Me?
We have seen how JourneyApps has created a unique paradigm amongst app development platforms — one that is not subject to the limitations of low-code/no-code platforms, while still offering unprecedented productivity, low cost and low risk.
In part 5 of our series, we will go into more depth on the business benefits that JourneyApps enables because of its unique paradigm of app development.
