The 4 Pillars Of Next-Gen Web Dev

Having witnessed the evolution of web development for more than a decade, I have gained some insight that will cause you to change course. The landscape is changing rapidly right now; people are rethinking TypeScript. These insights will help you navigate your path forward beyond TypeScript and towards a more stable and maintainable next-gen web application.

Modern web development has been dominated by the growth of JavaScript. Its footprint used to be small, served with some PHP. Then PHP with a little jQuery. But soon the demands of the modern web would outgrow what jQuery could provide. Then came the emergence of fledgling UI frameworks like Backbone, which brought some organization and structure to development. Then Angular, React, and others.

JavaScript seems like it is here to stay. But now there are many languages with strong type systems that compile to JavaScript or WebAssembly that are challenging TypeScript’s dominance. I believe the next generation of web development languages will be selected based on these 4 criteria.

Strong Type System

People choose languages for lots of reasons that sometimes add nothing of measurable benefit. Sometimes it is based on subjective likes or dislikes like “pretty syntax” or the use of semicolons or spacing. It may be based on current trends, or language choices of big companies. They may be interesting or more ergonomic, but a strong type system adds measurable benefits. These benefits include early error detection, developer confidence, constant development rate, reduced testing, fewer bugs, fewer runtime errors, and application logic completeness.

So we should know how to identify a strong type system. Here is what to look for:

• Type Safety: Invalid operations are caught at compile-time.
• Static Type Checking: Types are enforced before execution.
• No Implicit Coercion: Automatic conversions are prohibited.
• Expressive Types: Algebraic data types and pattern matching for precise data modeling.
• Compile-Time Null Safety: Explicit handling of null/undefined.
• Exhaustive Matching: All cases in logic must be covered.
• Type Inference: Automatic type deduction without compromising safety.
• Soundness: No type errors at runtime.
• Safe Array Access: Bounds checking to prevent crashes.

While a strong type system is important, it won’t be adopted unless it is familiar.

Language Lineage

Next-Gen Web Dev languages must fix the problems with the current language, but must also seem familiar. This is relative to your team and development ecosystem. For example, PureScript would be a familiar language for Haskell developers, but far too unfamiliar and requiring too much up-front investment for JavaScript developers. Its type system, though very robust, is far too distant from the type system within JavaScript or even TypeScript, and will likely be resisted for this reason.

It’s important to understand how languages evolve; they give clues of their deficiencies by adding features that attempt to solve them. For example, TypeScript brought a stronger type system to JavaScript, because JavaScript developers wanted more stable, maintainable applications. JavaScript also saw the addition of functional libraries like lodash, underscore, and frameworks like React, because JavaScript developers wanted more mathematical certainty in their applications, and simpler reasoning.

Next-Gen Web Dev languages will have a strong type system that fixes the problems of their parent language, but also feel familiar. But they’re not complete without being ready for the web.

Framework Readiness

The web is a complex place, and without a framework to guide development, you’re essentially back to the days of jQuery, where spaghetti code abounded, and each web application was broken in its own unique ways. A framework provides an opinionated way to develop web apps that works for the complexity of the modern web. This has been the power of React, Angular, Vue, and others, as it has enabled web applications to be developed in consistent ways, cross-project, cross-team, and cross-company.

A Next-Gen Web Dev language will either have a battle-tested framework or provide bindings to existing frameworks. But the transition to Next-Gen Web Dev should be gradual.

Incremental Adoption

The path towards Next-Gen Web Dev should be an evolution. This is to manage your risk, learn from mistakes, and gauge the success. Frameworks like Elm have provided insights into the industry that have proven beneficial. For example, Elm provided the insight that the view should be the outcome of changes to the state model. This concept was adopted enthusiastically by the creators of Redux, which continued to borrow other concepts from Elm like immutability, and the functional style. But Elm is not easily integrated into existing web applications, and so has served as more of an ideal to aspire to. On the other hand, languages like ReScript and PureScript compile to JavaScript, which makes incremental adoption possible, and enables the evolution towards Next-Gen Web Dev.

Final thoughts

So where are the trends pointing? JavaScript isn’t going away - yet. I foresee that JavaScript will be reduced to compiler output, while other languages will battle for dominance with WebAssembly as their compilation target. Once JavaScript’s role is significantly reduced, I imagine a new generation will be upon us, but that is too far ahead to see clearly right now.

In the near term, these 4 pillars form a solid foundation for you to advance into Next-Gen Web Development. Each has merit on its own, but only together will you achieve stable, maintainable web applications.

Ready to build or evolve your web applications based on all four pillars of Next-Gen Web Development? Whether you’re evaluating strongly-typed languages, planning an incremental migration strategy, or looking to modernize your development approach, my expertise can guide your transformation. Schedule a consultation to discover how Next-Gen Web Dev can elevate your projects →