Kentico recently updated their product roadmap. As is usually the case, there are tons of great new features for both platform users and developers. Let me bend your ear on some of the techie updates.
As we get nearer and nearer to the expected release in Q4 / 2015, I find myself daydreaming about two development enhancements in particular. Now, I don’t normally get too much time to daydream in the studio (lunchtimes and the occasional resourcing meeting). However, several enhancements keep popping into my brain as the issues they resolve have frankly been a bit of a pain point for us developers over the past few years. Thankfully, Kentico are great listeners and have been busy working on enhancements and new features that should address our grumbles.
Pain point #1: Continuous integration
We use TeamCity for continuous integration (CI) and are currently kicking the tires of Octopus Deploy for continuous delivery (CD) — both great tools with magic “Go” buttons that automate builds, testing, and the deployment of solutions. Tools like these are “must haves” for our process. In a sprint, the team will push multiple builds and release to all sorts of environments (QA, staging for content entry, dedicated builds for performance/load testing, client environments, etc.). Deployments need to be a “no brainer” that anyone in the team can handle.
Certain aspects of CI / CD with Kentico are difficult. All the necessary parts are there (at least on paper):
- Files in source control
- Methods to synchronize changes stored in the database (content staging & import/export
- The pain points come from the current limitations in the above features.
Source Control Mode
If you are using something like TeamCity to manage builds, then you really want all your code in source control. The issue with Kentico is that some of that code will be stored in the database. Kentico provides a great feature called source control mode that will export those objects from the database and get them into the file system so that you can manage them via source control. The pain point is that it doesn’t go far enough. Apart from content, we want all development and configuration objects in source control — otherwise, it doesn’t really solve the problem it was seeking to address.
So how do you get those other goodies deployed? To do this, you will need to use content staging and import/export. Both fantastic tools; however, they add another layer to that deployment you were hoping to automate. You do some work. You push a build. You then have to manually use either module to push a Page Type update, or a new configuration field that you added to a web part, for example. That means keeping track of those objects that you need to push with that build — and doing that for each release. Doesn’t sound like an unreasonable amount of work — but it soon adds up. We can say with certainty that the file system of our solution is at a given version, but the databases for each release can soon start to vary slightly (unless the team follows strict rules for content staging and import / export procedure). We’ve played around with scripts and code to help out, but this is an area where native platform support would really help out.
Kentico is taking this problem on with version 9:
With fully automatic deployment to another instance, Kentico will offer the ability to move all changes (code changes, physical files, and Kentico objects) from one environment to another using Source Control and a Continuous Integration server. Kentico 9 will also support the synchronization of work between developers and development teams with the same workflow for code as for Kentico objects. This solution works by offering the ability to store Kentico objects (including pages) in a file system, commit them to Source Control, and then retrieve and import them back into a different Kentico installation within a second environment. Additionally, this results in a full history of objects in the Source Control. This approach supports continuous integration needs, offers the power to provide continuous delivery, reduces the need for manual deployment, allows for better and faster detection of integration problems, and helps reduce and even prevent errors and loss of data, all resulting in reduced development costs. (Kentico Product Roadmap)
Pain point #2: MVC
Microsoft ASP.NET MVC is an 8-year old framework that implements everybody’s favourite model / view / controller pattern. It is an alternative approach to web development from the other framework that Microsoft offers, called Web Forms. MVC brings a better separation of concerns and easier testing than what you get currently with Web Forms. Kentico is built in Web Forms and loosely supports MVC; however, its real strength is the Portal Engine, which is built using Web Forms. The Portal Engine gives the editor fantastic page building tools that are modular, drag and drop, and support digital marketing features such as personalization.
It’s clear from Microsoft’s roadmap that although Web Forms will continue to be supported, they are moving forward with a focus on their MVC offering. This is a polite way of saying that Web Forms has no long term future.
Given the age of ASP.NET MVC, there are now senior ASP.NET developers out there who have never worked with Web Forms and frankly have no desire to learn the approach. Given what we know of ASP.NET 5, you couldn’t exactly blame any new developer from staying well away from it. Ask yourself — would you learn Flash right now?
Kentico wants great implementation partners. Implementation partners want great developers. Great developers tend to be the types of people who are keen to stay relevant with technology trends. Yet again — ASP.NET MVC is 8 years old. It graduated from being a trend such a very long time ago. Certainly, over the past year of doing interviews to find new developers, it has become increasingly clear that we are going to have to further minimize or remove our use of Web Forms over the next few years should we want to hire the best talent possible.
Thankfully, Kentico 9 will give MVC the love it deserves, and not just for developers:
The Kentico team will improve user experiences for both non-technical content editors and developers using the Kentico MVC development model… To improve the user experience for developers, Kentico will introduce a newer, cleaner API, as well as best practices for its use. (Kentico Product Roadmap)
This is great news and obviously, given the work effort involved, we can expect to see tighter integration evolve over future versions. I’m especially glad that there is a focus now on the editor experience as, for this to be successful, a formal MVC approach within Kentico can’t come at the cost of the editor experience — otherwise, it’s dead on arrival.
So hurry up, Q4
There are many other great features coming in version 9 (tagging and filtering in content staging also looks promising). Kentico aren’t just guessing about what might work in a future release. They are extremely proactive in reaching out to partners and customers for feedback, and to preview early concepts / prototypes. This version 9 roadmap is certainly reflective of that great communication.