KPMG gaat samenwerken met Omnext

KPMG gaat samenwerken met Omnext

KPMG gaat nauw samenwerken met Omnext, een Nederlandse leverancier van dienstverlening op het gebied van softwareanalyses en de eerste door OutSystems erkende Code Review partner.

De samenwerking stelt KPMG in staat organisaties die gebruik maken van op OutSystems gebaseerde software een beter inzicht te geven in de onderhoudbaarheid, betrouwbaarheid, prestaties en beveiliging van hun applicatieportfolio. KPMG gaat met name gebruik maken van de Fit Test 4 OutSystems tool van Omnext bij de statische analyse van toepassingen die zijn gebouwd met behulp van het OutSystems-platform.

Langdurige relatie

KPMG heeft een langdurige relatie met OutSystems. “Sinds 2010 leveren OutSystems en KPMG Portugal samen een aantal bijzondere IT-oplossingen”, zegt Joost Koedijk, partner Digital Enablement bij KPMG en wereldwijd verantwoordelijk voor de praktijk die zich bezig houdt met softwarekwaliteit.

Koedijk: “Dat heeft in 2011 geresulteerd in een officiële samenwerking. De bedrijven werken nauw samen om de inspanningen die op het gebied van digitale transformatie worden gedaan in een aantal sterk gereguleerde branches in goede banen te leiden. Dat geldt bijvoorbeeld voor de bankensector en de telecommunicatie. KPMG Portugal heeft meer dan zeventig professionals in dienst die gecertificeerd zijn voor OutSystems.

In 2018 is de samenwerking uitgebreid met KPMG Nederland en hebben wij een nieuw Center of Excellence ontwikkeld voor OutSystems op basis van de bestaande capaciteit. In datzelfde jaar werd KPMG door OutSystems uitgeroepen tot Partner of the Year.”

Continue monitoring

“Met ons Fit Test 4 OutSystems platform monitoren we continu, geautomatiseerd en op transparante wijze de kwaliteit van de met het OutSystems platform ontwikkelde software van onze opdrachtgevers”, zegt Jaco de Vries, CEO van Omnext.

De Vries: “In 2018 is Omnext door OutSystems al erkend als hun eerste officiële Code Review Partner en in onze ogen is de samenwerking met KPMG de volgende stap om organisaties op internationaal niveau in staat te stellen om de kracht van het low-code platform optimaal te benutten door kwaliteit te waarborgen. Daarnaast biedt KPMG een hoog niveau aan OutSystems-kennis, welke ons in staat stelt om ons Fit Test platform continu te blijven verbeteren. Een samenwerking met het oog op de toekomst dus.”

Werk uit handen

KPMG helpt klanten inmiddels meer dan een decennium om inzicht te krijgen in de technische kwaliteit van hun applicaties op traditionele platformen, zoals .NET, Java en PHP.

Koedijk: “Met Fit Test 4 OutSystems breidt KPMG zijn adviesdiensten voor softwarekwaliteit uit naar het OutSystems-platform. Als het op de juiste manier wordt toegepast biedt OutSystems een platform dat ontwikkelaars veel werk uit handen kan nemen. Implementaties kennen uitdagingen die vergelijkbaar zijn met traditionele ontwikkelplatformen, en in het algemeen zullen fouten dan ook voorkomen.

Een tool zoals Fit Test 4 OutSystems stelt ons in staat om een ​​grondige geautomatiseerde analyse te maken van de technische kwaliteit van de ontwikkelde software. Op deze manier kunnen wij onze klanten helpen om de kwaliteit en het onderhoud van hun softwareoplossingen te verbeteren.”

Maintainable Code in the Era of Low-Code

Maintainable Code in the Era of Low-Code

Omnext just announced a new service for customers to help them understand the code maintainability of applications they build with OutSystems. This begs the question, what is maintainable code when we’re talking about a low-code platform? In this post we’ll highlight why this is a very relevant question to be asking, and why companies like KPMG (who build many low-code applications and happen to be “OutSystems 2018 Partner of the Year”) take this seriously.

Speed vs. Quality

Speed versus quality is a classic balancing act that applies to the process of building software. For those who prioritize quality, it makes sense that there would be a healthy skepticism of development platforms that promise greater speed. “If a platform helps a developer build software 10 times faster, surely this will lead to quality issues,” might be the thought process.

To address this concern, it’s helpful to substitute the word “speed” with “automation.” The speed increases delivered by low-code development platforms relate to things developers no longer have to do. Various studies show that as much as 60–80 percent of development time is spent on repetitive activities. The way we write code to take data from a database table and present it on a screen doesn’t vary much from screen to screen. The way we ensure a screen displays well regardless of form factor tends to be the same for each screen. The way we ensure security, internationalization, accessibility… you get the picture.

There are many accelerators already built into the leading IDEs to help automate these types of activities by generating various snippets of code. Low-code development platforms extend this further by allowing developers to visually model solutions without even having to write code. The platform takes care of all the repetitive stuff. Does this mean the developer is no longer coding? Absolutely not. The developer still has to model the logic and data of the application, design the screens, connect to data sources, maintain good architecture, and so on.

Speed vs. Control

Assembly Language Macros

This claim of 10x development speed is often perceived negatively by developers who worry they are losing control over the “code” of their application. I think of it differently. My first coding job was in assembly language, and it took forever to do even the most basic things. When macros were introduced to automate instruction coding for assembly, there was a similar concern from developers: “I don’t like it! I’m losing control!” When I transitioned to C++, I didn’t once miss loading registers or trying to squeeze code into a 4k segment—I was able to focus instead on what the software needed to actually do. Then came Java. No more worrying about garbage collection or wrestling with apps that needed to run on more than one operating system or platform. This felt like nirvana compared to before.

Each of these language evolutions automated many of their predecessors’ tasks; tasks that consumed so much of my time as a developer. Instead of hunting down memory leaks, I could focus on solving the business problem. The automation that low-code development platforms provide is the reason teams are able to deliver software substantially faster. I would say that those who worry about this being a loss of control are just kidding themselves. To me, that’s like worrying about what happens to your Javascript code after it is written.

Back to Quality

Growing up in the U.K., the phrase “more haste, less speed” was commonplace, and I never really thought too much about what it meant. Thanks to automation, low-code enables a much higher degree of “haste” than lower-level programming languages. You can deliver meaningful outcomes to the business faster compared to manual coding. But, like any programming language, a developer rushing to deliver solutions with low-code can make mistakes. “Speed” without quality can result in a poor architecture that, in turn, leads to issues in areas like performance, security, or maintainability.

So, how do you ensure quality with a low-code development platform? It turns out that it isn’t really that different compared with traditional programming languages. Best practices are defined that have to be checked, either manually or, better yet, with automation.

Enter Omnext

Omnext is a company focused on providing automation solutions that ensure the quality of software written in over 30 different languages. They have developed a solution for OutSystems customers based on the ISO-25010 guidelines for software maintainability and quality supplemented with OutSystems-specific best practices. They help organizations answer the following types of questions across a portfolio of OutSystems applications:

  • How has the maintainability changed since the last sprint?
  • How do the code quality and productivity of my scrum teams differ?
  • How can I reduce my maintenance costs?
  • To what extent are components re-used?

Omnext Fit Test provides a snapshot of an app’s current software risks. Customers can also sign up for a regular cadence of risk scans with the Stay Fit program. Results of the analysis are presented in an elegant dashboard within the Omnext Portal. A point-based scoring system makes issues easy to identify.

Omnext Dashboard

Omnext has developed their own ORQA index, a quality score based on the impact of any best practice violations and the effort required to resolve them. Adapted to include OutSystems best practices gathered from years of experience across large portfolios of applications, this index can be used to help prioritize any remediation efforts.

By comparing points-in-time, you can see whether new issues are being introduced as your teams deliver new releases. To facilitate the fixing of issues, the Omnext Portal provides more detailed views to help pinpoint exactly where in your OutSystems model those issues were found. Since organizations may have different standards, custom rules are also supported to further tailor the results of the analysis.

Omnext Code Analysis Dashboard

Tangible Benefits of Understanding Quality

Intuitively, we want our software to be of higher quality. When it comes to security and performance, the potential repercussions of low quality are self-explanatory. Low-code maintainability may have some less obvious benefits, but they, too, are important.

Future Readiness

Applications that are built following best practice guidelines are likely to last longer and add value to their users for a longer period. They are also easier to adapt to changing requirements.

Reduced Maintenance

It is easier to maintain an application that is built well. Less time spent on maintenance means extra time available to deliver new, high-value functionality.

Enhanced Reusability

Well-architected elements are more likely to be used again, and reuse can increase productivity.

Improved Skills

Sharing quality insights with your development team helps them understand how to architect higher quality applications, raising the overall skill level of your team.

Ultimately, while the higher level of abstraction enables much greater speed, developing with low-code is not that different compared to writing code by hand. Quality still needs to be built into your development practices, and by automating your quality checks, further efficiencies can be gained.

To find out more about how Omnext can help you identify opportunities that might be hiding in your OutSystems applications, check out their website. For a limited time, they are offering a free Quick Fit Test scan of an application. For those who need more assistance, Omnext has partnered with KPMG so you can take advantage of their depth of experience with OutSystems. KPMG will conduct expert reviews of an organization’s applications and draft up detailed improvement reports.

Now, go in haste.

Written by Mike Hughes – Senior Director of Product Marketing, OutSystems.

Link to original post: https://www.outsystems.com/blog/posts/maintainable-code-low-code/