Tag: Low Code

  • Dual-Track and Low-Code’s Excellent Adventure

    Dual-Track and Low-Code’s Excellent Adventure

    Digital transformation can be a bogus journey. Here’s how low-code and dual-track transformation efforts can help.

    Large-scale enterprise digital transformation can take a while. Transformation initiatives like cloud migration, mainframe upgrades or refactoring monolithic systems could easily take five to seven years. Yet, this slow pace is at direct odds with today’s digital innovation standards and the pressure to release software rapidly.

    COVID–19 has amplified this drive to innovate, especially complicating matters for non-cloud-native companies, which struggle to attract and retain talent amid a developer shortage. Not to mention, developers are experiencing surmounting pressure to perform, which could result in burnout if not supplemented by new strategies.

    To maintain agility while diligently advancing multi-year digital transformation projects, some proponents argue for a dual-track approach. This approach uses low-code platforms to increase operational agility (the fast track) while digital transformation initiatives (the slow track) progress methodically on the side.

    I recently sat down with Jay Jamison, chief product and technology officer at Quickbase, to discuss today’s digital transformation concerns. According to Jamison, implementing a dual-track approach affords great rewards, but it requires an organizational cultural shift. He recommends establishing centers of excellence (COE) to evangelize low-code practices and encourage citizen development, enabling subject matter experts of lower technical acuity to automate operational workflows and operations.

    Dual-Track Transformation

    “Digital transformation is an important element for businesses of all sizes,” said Jamison. However, mainstream digital transformation projects, like rationalizing an ERP, moving to the cloud, or upgrading a network, can take an exorbitant amount of time and money. It’s hard for IT to meet business requirements. “We really need a second track of digital transformation — one that is more agile.”

    Jamison likens dual-track transformation to chipping out “small rock” projects from the larger digital transformation cliff. This strategy focuses on streamlining realizable goals in shorter timespans, empowering teams of people — with subject matter expertise — with tools to transform and digitize their workflows.

    Low-Code’s Role in Dual-Track

    A recent study conducted by Harvard Business Review found that 80% of executives “strongly agree” that a dual-track approach is essential for digital transformation. Yet, only 31% of companies have adopted said approach.

    To realize a dual-track process, Jamison recommends low-code for its “low-risk, high-throughput capability.” According to Jamison, low-code enables the edge of business to quickly adapt new solutions and run them in parallel with big rock digital transformation. For example, non-engineer government employees in a Texas county recently used a low-code platform to help distribute coronavirus vaccines.

    For a citizen developer culture to flourish, “you really need to have all hands in the pile,” Jamison said. IT stakeholders and business members must collaborate and work together to bring low-code to fruition. This process combines setting goals, outlining guardrails, and forming learning groups with progressive leadership at the helm.

    Introducing Centers of Excellence

    Naturally, many factors can affect IT innovation (leadership commitment, collaboration, organizational expectations, etc.). But arguably, the most common roadblock to digital innovation is culture. In fact, 45% of executives report that organizational structure is a major transformation challenge.

    That’s where centers of excellence (COE) come in. No, centers of excellence is not an archive of Bill & Ted’s adventures. COEs aim to fix the cultural barrier by encouraging progressive leadership, collaboration, and innovation. The Playbook for Centers of Excellence defines COE as “a concentration of expertise and resources in a specific capacity, designed to maximize the focus on a specific project.”

    A COE aims to foster shared understanding between IT leadership and business leadership. In Jamison’s words, “a center of excellence provides the ability to utilize low-code to sustainably build and empower applications in a safe, sustainable way.”

    Building a Most Triumphant Center of Excellence

    The COE goal is to empower business users to innovate. Yet, COE is a governance framework, which seems a bit contradictory. So, how does an organization go about implementing it? Well, there is a range of how companies adopt COE, but Jamison shared some common steps:

    Step one is establishing your goals. This could be increasing productivity, enhancing customer satisfaction or improving service reliability. Step two involves inviting the right people and perspectives — the key personnel to own the COE program.

    Next, develop transparent policies around security. This helps preempt concerns around data security and compliance. Finally, now that goals and rules are established, communicate the initiative across an organization.

    Throughout this process, investing in training is paramount. There are many project management philosophies for encouraging low-code adoption, but Quickbase recommends a training and education team to “roll out information and goals in a structured, targeted way”. They also encourage a community focus — user groups, internal events and knowledge-sharing initiatives can build excitement within the employee base.

    Benefits of Low-Code Enabled COE

    A COE aims to bring disparate parties to the same table. For example, companies could hold what Jamison described as an “appathon,” in which business executives present their goals, like rolling out new installations or driving 5G deployments. Then, priorities are assigned to individual groups, who apply domain knowledge to construct applications.

    Setting up a COE by accelerating ground swell innovation “catalyzes the dual-track innovation that we think is really key,” said Jamison, reducing the mean cycle-time to introducing new features. Low-code could also lower the integration barrier, enabling connectivity with CRM systems, or connecting with big, heavy systems like SAP or Oracle.

    Jamison also described low-code platforms as encompassing “the spirit of microservices,” as they introduce a relatively lightweight application process and easy deployment model. Furthermore, if teams are tapped into the same PaaS, they receive data reusability benefits, he said. “Everyone can utilize the same data in a way that’s relevant for what they need.”

    Citizen Developers: Bogus or Non-Bogus?

    Personally, I think it would be great if the future of application development ushered in a democratizing effect, allowing more people to participate in software creation. Yet, the skepticism around a fully working citizen developer model is hard to shake.

    The “citizen developer” seems to have a negative connotation among coder elites, too. As one reader commented:

    “So top talents are overpaid extravagance and bored secretaries working from home will be driving innovation by writing no-code workflows, am I right with understanding what is written here?”

    I pressed Jamison on the reality of the citizen developer concept in practice and how he responds to naysayers. He jokingly equates it to a witch hunt.

    “Saying that only people that get to participate in software development is professional software developers is ridiculous,” he said, noting the importance of subject matter expertise.

    According to Jamison, companies often fail when they attempt to transmit subject matter expertise to developers. Organizations would rather teach subject matter experts low-code than teach the subject matter to programmers, he noted. It’s not hard to imagine why allowing subject matter experts to build their own workflows for specialized fields, such as accounting, natural science, or mathematics, makes sense.

    Regardless, Jamison adds there’s nothing really to worry about — “The full stack developer isn’t going anywhere.”

    Dual-Track Digital Transformation? Excellent!

    A dual-track approach combines large-scale transformation and rapid-cycle development. By separating “small rock digital transformation” out from the larger puzzle, organizations can increase operational agility to meet business needs a bit quicker.

    Establishing a center of excellence seems to boil down to bringing people together to share ideas, collaborate, and drive better productivity. If anything, this way of thinking will help operationally-intensive industries consider how they can automate parts of their business.

    Ultimately, the goal here is to enable organizations to collaborate better and drive better productivity. By empowering more creators, you can start seeing creativity at the edge of business emerge too, said Jamison. If that involves citizen developers creating event-driven workflow automation, so be it. “We invite people to take on the challenge,” said Jamison.

    Hopefully, then, business and IT can be excellent to each other.

  • DARPA Enlists GrammaTech to Apply AI to Reverse Engineer Code

    DARPA Enlists GrammaTech to Apply AI to Reverse Engineer Code

    The Defense Advanced Research Projects Agency (DARPA) has awarded a research contract to GrammaTech for low code technology that will make it possible for end users to leverage artificial intelligence (AI) without requiring intervention from the original software developer.

    GrammaTech’s AI tool, dubbed ReMath, aims to ease application updates by automatically inferring high-level mathematical representations from existing binaries in systems and embedded software. The tool is currently in development.

    Dr. Alexey Loginov, vice president of research for GrammaTech, said development teams spend a lot of time using low-level tools such as disassemblers, debuggers and decompilers to manually analyze binaries. ReMath will accelerate that reverse engineering process by recovering and converting machine language into representations that end users can directly manipulate, said Loginov.

    The goal is to free developers up to build new software, rather than continuously updating software that has already been deployed, noted Loginov. This approach should ultimately reduce the backlog of application and software development projects organizations have, added Loginov.

    GrammaTech

    The ReMath project is the latest in a series of DARPA contracts awarded to GrammaTech. In general, the company is working towards applying AI to advance DecSecOps via a static application security testing (SAST) tool that identifies vulnerabilities in code. The ReMath project focuses on applying AI to use cases involving, for example, industrial control systems. These systems could benefit from allowing domain experts, with no coding expertise, to maintain and update them on their own, said Loginov.

    Other DARPA projects GrammaTech is actively researching include a type-ahead capability that automatically recognizes existing artifacts in a software repository, said Loginov. This capability will make it simpler for developers to reuse code within the context of a GitOps process without inadvertently introducing additional errors, Loginov said.

    In the future, the potential impact of AI on software development could be profound, as more reliable code moves into production environments. The percentage of code graduating into those environments on the first attempt should increase considerably in the years ahead. That should enable more reliable delivery of application code via continuous integration/continuous delivery (CI/CD) platforms.

    As software development becomes more efficient, the current developer shortage should also ease, and open up resources to launch a greater number of application development projects. Rather than spending time on manual tasks that provide no differentiated value, Loginov said software engineers will be able focus more of their time and energy on process innovation.

    In the meantime, developers should expect to see a rash of development tools with AI capabilities in the months ahead. None of those tools are likely to eliminate the need for developers any time soon; however, much of the drudgery involved in writing code today is likely to be sharply reduced as machine learning algorithms and other forms of AI are applied to software development.

  • Low-Code Opens API Integration Potential for Citizen Developers

    Low-Code Opens API Integration Potential for Citizen Developers

    APIs have an accessibility problem. Could a low-code API approach make them more inclusive and accessible for citizen developers?

    Most software today integrates with third-party SaaS. TomTom for geolocation. Stripe for payment. Twilio for SMS. Kairos for facial recognition. AWS for NLP … the list goes on. Whatever function you’re looking for, there’s probably an API for that.

    These specialized utilities help software teams avoid reinventing the wheel for things outside of their core competency. They’re standardized, too — most services are programmable following REST or GraphQL guidelines. Serving integrations over HTTP aids in decoupling the business logic from the client interface. Furthermore, OpenAPI Specification, now part of the Linux Foundation, has risen as a standard description format, making APIs more defined and interoperable.

    However, for all this progress, there’s still friction in the integration process, even for seasoned developers. Each API is a bit unique. It takes time to read through the documentation to authenticate and discover methods, parameters and accepted fields. It requires effort to test requests within Postman, decipher error messages and set up calls within your unique environment. On top of all this, downtime and breaking changes are legitimate concerns for over-the-wire dependencies.

    APIs require effort and maintenance, and just integrating third-party APIs alone won’t build you a fully functional application. Yet, organizations find themselves scrambling to find and hire engineers, and increasingly the onus is on non-tech folks to create new digital workflows. Naturally, companies are currently searching for even more low-code solutions.

    So, what’s the glue holding together API products? How can we better connect APIs to the software applications we’re already building and allow citizen developers to reap the benefits?

    My theory: If low-code platforms decrease the API integration hurdle, more problem-solvers can stitch together business utilities to create more advanced internal applications. Making third-party APIs more inclusive for citizen developers could boost the API economy at large and enable creative solutions to flourish throughout enterprises.

    The Need for Low-Code API Integration

    Perhaps the best way to demonstrate the need for low-code is to scare you with some code. Let’s say you want your application to initiate a direct deposit into a bank account.

    You don’t want to build a financial service from scratch, so you turn to Stripe API. You set up an account, grab a key, and dig in to the ‘Getting Started’ materials. You peruse their comprehensive documentation, and find out how to create a payout.

    The docs demonstrate a sample HTTP curl request for creating a payout. Other parameters to pass include destination, methodor source_type.

    curl https://api.stripe.com/v1/payouts \
     -u sk_test_4eC39HqLyjWDarjtT1zdp7dc: \
     -d amount=1100 \
     -d currency=usd

    If there are no errors with the request, the response will be a payout object, formatted in structured JSON. It details the balance, data created, currency type and other fields. It looks something like this:

    {
     "id": "po_1HmNKQ2eZvKYlo2CuRNBRWUW",
     "object": "payout",
     "amount": 1100,
     "arrival_date": 1605116514,
     "automatic": true,
     "balance_transaction": "txn_1032HU2eZvKYlo2CEPtcnUvl",
     "created": 1605116514,
     "currency": "usd",
     "description": "STRIPE PAYOUT",
     "destination": "ba_1HmNKQ2eZvKYlo2CzlT6m5gk",
     "failure_balance_transaction": null,
     "failure_code": null,
     "failure_message": null,
     "livemode": false,
     "metadata": {},
     "method": "standard",
     "original_payout": null,
     "reversed_by": null,
     "source_type": "card",
     "statement_descriptor": null,
     "status": "in_transit",
     "type": "bank_account"
    }

    Now, you can parse the response into data your application can ingest. You can also send other requests to update, return and cancel this payout object.

    For specialists familiar with HTTP calls and JSON, this is pretty straightforward. Stripe docs typically generate sample requests for many languages, like PHP, Ruby, Python and others to help within your own environment.

    But what if your users are more comfortable with UIs? Integrations are pretty opaque to the non-technical. Even for seasoned developers, APIs can quickly become too dense, and not all have a great developer experience.

    Hurdles In API Integration

    There are many issues preventing non-tech-savvy users and novice programmers from inserting API-driven business logic into their applications:

    • Onboarding time: Setting up an account, acquiring authentication, reading docs and testing calls to familiarize yourself all takes time.
    • Data Types: Data passed in headers must conform to explicit data types, or else requests may fail.
    • Parsing: Responses are often too verbose; developers must parse the JSON object responses to retrieve the data they need.
    • Programming language: Each language handles network communication differently, meaning requests look different in every language.
    • Breaking Change: Third-party services change often, so if you’re not actively maintaining an integration, you may face breaking change.
    • Differing formats: There are various API standards. REST, SOAP, GraphQL all are designed a bit differently. Plus, webhooks, event-driven and publish-subscribe patterns have nuanced communication models.
    • Security and legal: If APIs aren’t appropriately secured, hackers could easily steal user data or cause outages.

    As you can see, a simple programming task like “make a bank deposit” becomes extremely complex the more closely we look at the logistics of actual implementation.

    Furthermore, just because you’ve made an integration work, that doesn’t mean you have a fully-functional application, securely deployed in the cloud, with a friendly UI  that’s universally accessible. A single application may have numerous integrations, meaning the integration process must be duplicated for every external service you connect.

    API Categories

    Overcoming these challenges is a lot to ask of non-professional developers, who may not be comfortable consuming business applications from the command line. This issue is further compounded as integration extends beyond public APIs, too.

    In a recent interview with Divyesh Kharade, co-founder/CEO at DronaHQ, he identified three main API categories:

    • Ready-made SaaS APIs: Microsoft Teams, Slack, Sendgrid, Twilio, Google Sheets, etc. These are the connections to third-party operational business utilities and applications.
    • Connecting to databases: Many companies require secure connections with custom internal databases or legacy internal MySQL databases.
    • Internal custom software: These are private or partner APIs. They may be new API-first microservices or custom-built legacy internal apps. Such middleware may expose many APIs.

    If a low-code application wants to become a holistic software development add-on, it must anticipate all potential environments. This includes integration realities for various scenarios.

    Citizen Developer vs. “Non-Tech”

    So who, exactly, benefits from more accessible integrations? The term citizen developer is often used to refer to any non-professional software developer with minimal programming training. “When most people speak of citizen developers, they mean functional guys that can build tech,” says Kharade.

    As I’ve said previously, fostering a culture of citizen developers is becoming a bigger priority amid dwindling developer talent and a combination of other forces impacting software development requirements.

    Yet, citizen developer tends to means something a bit different to everyone involved in the low-code space. Kharade seems to prefer the term “non-tech.” Non-tech users may include designers who may not have a software background but the relevant UX/UI knowledge to assemble workflows. “Design is a big part of any application,” said Kharade.

    Masking the Complexity of APIs

    If low-code tools mask complexity and make APIs more accessible for these non-engineers, it could inspire many creative solutions. With low-code, “creativity is limitless, and integrations really help with that,” said Kharade. “Once they see that power, they aren’t going back again.”

    For example, if an internal application requires chat functionality, Slack could be a great addition. Low-code layers could hide complexity in the backend, to the point that it “doesn’t feel like a request in background,” noted Kharade.

    The solution works both ways. Utilizing low-code platforms to manage data and expose APIs could enhance visibility and extensibility. Kharade described an industrial manufacturing use case, in which shift workers manually entered machine operations data on paper. That was before COVID; once lockdowns were mandated, the company started digitizing this record-keeping process.

    Access to real-time data, and the ability to filter and organize historical data, is already beneficial.  “Six months down the line, they may consider how to make this data accessible using APIs,” said Kharade. “The journey has just started — it will only get smarter and better.”

    Trigger-Based Workarounds Were A Start

    Of course, tools like IFTTT and Zapier have already been making APIs accessible to laymen for years. These platforms use friendly, UI-based front ends over the foundation of complex integrations, allowing users to set up trigger-based automation. If this particular service does this, this other service should do that.

    These are cool tools for stitching together service-service communications. However, these workflows are a bit isolated from the larger application development picture. For example, an application for hiring employees may require more than connecting a form API’s input to a Google Sheets field. This could require a custom database, a way to upload documents and the ability to deploy an application to the cloud.

    Since low-code already has standard components for drag-and-drop, adding a common method to insert third-party API integrations feels like a natural feature enhancement for these platforms.

    Making Integration More Accessible

    ProgrammableWeb records 23,000 APIs as of this moment. Clearly, many innovative, programmable SaaS offerings are ripe for the picking. Some paid, some open, all with slightly different integrations.

    “It’s difficult for a non-tech user to register and interact with an API,” said Kharade. Figuring out authentication, OAuth, headers, payloads and responses requires expertise. Though a professional developer may be required to “register them once,” says Kharade, once third party integrations are set up, they “should be drag-and-drop and click-to-use.”

    Solving integration problems is just one of the many arenas where low-code platforms could shine. If platforms can successfully establish (and maintain) connectivity, consumers could more easily access the core logic they are searching for. Democratizing robust solutions for traditionally non-tech companies is especially important amid the COVID-19 crisis.

    To be clear, I don’t believe it’s the API provider’s job to cater to end-users. Instead, they should focus on creating excellent developer experiences. Naturally, the type of business application you are trying to construct and your access to software engineering talent will, to an extent, determine a project’s technical stack. The JAMstack style, for example, may be a better fit for your team’s makeup and project objectives.

    That said, there seems to be room in the market for additional low-code layers to open up integration. In the same way APIs avoid reinventing the wheel for specialized utilities, low-code layers could standardize the pains of integration itself.

  • Low-Code To Become Commonplace in 2021

    Low-Code To Become Commonplace in 2021

    A new study finds 85% of engineer leads predict low-code and no-code will soon become common

    New findings from an Internal-endorsed study suggest 2020’s software development challenges will undoubtedly carry into 2021. Many businesses are making immediate transitions to a digital-only economy, forcing a ton of new app development requirements. Yet, hiring top engineering talent is especially difficult, amid a developer drought and pandemic uncertainties.

    One in three organizations has implemented a hiring freeze. Respondents also cited rising development challenges and insecure internal software, putting a strain on normal operations. To help address these challenges going forward, a whopping 85.1% believe implementing low-code and no-code will become more and more omnipresent within their company.

    Below, we dive into the report’s major findings, which surveyed 500 IT and engineering workers at medium-to-large enterprises. Using this data, we’ll forecast hurdles software development teams may face in 2021, and gauge if low-code tooling adoption is the ultimate panacea or no more than a Band-Aid for a much larger ongoing problem.

    Development Challenges Will Increase

    In the thick of the pandemic, software is often the only touchpoint many traditional companies have with a user. Naturally, the number of digital experiences required to meet this new reality is skyrocketing. Experts and data show this trend has no signs of stopping.

    In fact, 60.1% of surveyed saw app development increasing due to work-from-home policies. Only 9.7% reported a decrease in app development. One could easily attribute rising app development with growing software requirements brought on by the current digital-first climate.

    In this new economy, finding bold ways to increase productivity is critical. Improving the efficiency of engineering teams was a priority for most respondents and a high priority for 40% of respondents. For small groups with lean margins, improving automation for software delivery could help compete with larger players.

    Talent Will Become More Competitive

    The biggest challenge employers face is finding talent—30.6% of respondents cited increased competition for talent as a top challenge in 2020 and 22.2% also recognized developer drought as a significant obstacle. If you had trouble finding skilled software engineers in 2020, good luck next year …

    Looking to 2021, 45% see competition for talent remains a top challenge. Trailing problems include developer drought, immigration issues and a poor reaction to new work-from-home policies.

    Hiring Practices Will Continue to Shift

    With COVID–19 in full force and a developer scarcity, you’d think hiring would come to a freeze. Yet, the results of this study were mixed—hiring practices are pretty varied across teams.

    According to the report, 34.5% of organizations surveyed had paused hiring new engineers. Conversely, 37.3% have hired more engineers, and 18.5% of organizations reported no change to hiring practices at all. About 10% had layoffs.

    Whereas some tech companies are thriving in the new normal, others may pause hiring due to uncertainness around COVID-19. These companies could be turning to low-code technologies as a replacement. “If you pause hiring, you still need to build, and low-code is a great option for that,” said Arisa Amano, CEO of Internal.

    Low-Code Will Become Commonplace

    To address the above issues, companies are turning to low-code solutions. These platforms help relieve the development burden for internal business tools and open up citizen developer use. And, it’s more than a fad—the report was able to squarely demonstrate an uptick in low-code use.

    Most companies (75.2%) have already implemented a combination of low-code and traditional engineering methods. It appears that low-code is complementing existing software engineering practices at a number of institutions.

    In addition, 28.8% of respondents predict low-code and no-code will become a high priority in the coming months, and for 21.6%, it will become an essential focus. Impressively, 85.1% of developers foresee low-code and no-code as becoming more commonly implemented within their company.

    Low-Code Will Open Doors for Non-Tech

    The citizen developer concept has been gathering marketing steam, but it might not be just hype. Now, data suggests low-code tools are actually opening doors for such non-developers. Seventy percent of companies said non-developers in their company already build tools for internal business use, and nearly 80% predict to see more of this trend in 2021.

    It should be noted that low-code and no-code do not seek to replace all engineering talent; instead, to free them up to engage in more complex tasks. “With low-code, you free up your engineers to work on harder problems, instead of having them work on basic things,” said Arisa Amano, CEO of Internal. She believes this could translate into more innovation companywide.

    Surprisingly, bringing non-traditional engineers into the development fold is not being met with ambivalence—69.2% of respondents foresee that citizen developers positively affect engineering teams, with the rest primarily exhibiting a neutral reaction.

    Improved Access Control Will Boost Internal Security

    The costs of internal security threats are high. Breaches could decrease customer trust, harm brand reputation and lead to escalating legal fees. With cyberattacks a prevalent concern, cybersecurity must come back in style.

    Not only are threats external, but internal too—46.8% of respondents were extremely concerned about employees having access to customer data. The cause for concern is duly noted, as the majority, 58.1%, have experienced internal data security breaches in the past.

    The reasons for internal breaches vary across the board. Respondents attributed the top cause simply to a rise in the number of employees and contractors with access to sensitive information—a surge in employees means a greater chance of human error or leaked credentials. It also means an increase in the number of devices with access to sensitive data—this is particularly tricky, as CISOs face a dilemma on how to govern privileged access for housebound laptops and mobile devices.

    Respondents also noted the increasing complexity of technology and the overabundance of new cloud applications. It’s hard to expect DevOps to secure modern infrastructure when they’re still trying to figure out how it works! As a knowledge gap could quickly introduce vulnerabilities, 62.7% of respondents are actively investing in increased employee security training.

    Other security problems, such as a lack of granular access control or lack of logging and audit trails, seem like they could be mitigated with the right configurations and DevSecOps approach. In fact, 55.4% of respondents are in the process of baking in fine-grained access controls. “Having that at the forefront of internal tools is key,” said Bob Remeika, co-founder, Internal.

    Shifting security left could correct an age-old trend of adding security after the fact, which only prolongs the problem. On the whole, companies require a combination of better access enforcement, multi-factor auth and increased monitoring to mitigate mounting threats.

    Low-Code Becomes Mainstream in 2021

    Software development teams face many challenges in the coming year. Demands for new software will increase and processes to increase efficiency will fall under the microscope. Rising engineer competitiveness and developer drought will also continue to shift hiring practices.

    Companies that weren’t 100% digital will be forced to embrace the new norm and develop internal software and automation. Yet, building internal tools isn’t straightforward and will be especially difficult for companies less technical than their software-as-a-service counterparts. All this, paired with ongoing security threats, means internal app development in 2021 has its challenges.

    Although conditions look dicey, the underlying issues are not unusual, Remeika said. They have just been amplified. “There’s always been a developer drought, companies have always been trying to find ways to do more with less, and competition for talent is never getting less fierce,” he said.

    Though we’ve seen a spike since COVID-19, the desire to offload work has been everpresent. Remeika believes sophisticated low-code platforms will empower technical non-engineers and assist with things people typically tend to disregard when building internal applications, such as security, deployment, testing and review capabilities.

    Nevertheless, development team output appears to be resilient throughout work-from-home policies. And as I recently covered, a low-code movement could also enable a democratization effect, helping SMEs who can’t afford the top talent to still compete at the same table as large tech companies. We expect low-code and no-code adoption to spill well into 2021, seemingly, as a panacea to these mounting concerns.

  • Demystifying the Low-Code Category

    Demystifying the Low-Code Category

    The low-code category is estimated to grow substantially in the coming years. By 2024, Gartner projects 75% of large enterprises will have adopted four low-code or no-code tools for both IT application and citizen development needs. But what exactly is low-code, and what are the scenarios in which it is needed?

    Low-code, like so much other software jargon, is somewhat ambiguous. Under this umbrella term exists a well of various tool types—website generators, form builders, API connectors, database builders, workflow automators and more, each requiring varying levels of technical proficiency. Some are 100% codeless and UI-based with drag-and-drop templates. Others need programming acumen to set up to complement a developer’s pre-existing workflow. When we talk about low-code, we’re typically referring to platforms that help create internal business utilities.

    I recently connected with Divyesh Kharade, co-founder and CEO at DronaHQ, to demystify the low-code category. Below, we define citizen developers, break apart low-code versus no-code and dig into specific types of low-code scenarios. Given this knowledge, technology leaders can better identify what tools they need to increase rapid development for their business needs.

    Hard Code Is to No-Code as Manual Is to Driverless

    So what’s the difference between traditional coding, low-code and no-code? To demonstrate the nuances between emerging code paradigms, Kharade compares them to automobile types.

    Manual Coding

    Traditional coding is like a manual car with a gearbox

    With a manual car, you must know how to switch between gears. Not to mention, you must understand driving itself and how to navigate busy streets, all while following traffic laws. We can compare manual driving to traditional coding. Manual coding is for trained developers.

    For example, consider we need to develop an application to interact with a database. To create this from scratch, this could mean coding a PHP application, connecting it to a back-end database management system such as PostgreSQL and hard-coding commands for ingesting data and manipulating entries.

    Manual coding requires an adept understanding of programming languages and development frameworks and libraries and collaborative development processes such as git. Naturally, traditional coding is in the professional developers’ realm and often necessary for software teams developing proprietary software-as-a-service offerings. It affords ultimate customizability.

    Low-Code

    Low-code is like an automatic car

    With an automatic car, you must still know how to drive, but gear-switching is automated. Cruise control is a nice perk, too. Similarly, low-code seeks to make development easier. It even enables some non-tech folks to construct applications. Low-code is used by professional developers and citizen developers.

    If we consider our database example, a low-code solution would likely involve a one-time registration of a database. This would require a little technical expertise to initiate, Kharade said. However, after which, it would be smooth riding—a user interface would be utilized to develop applications that interact with the database.

    Low-code platforms often incorporate various drag-and-drop building blocks to help develop applications. These pre-generated components may include tables, textboxes, dropdowns, charts, maps, forms, user directories and other elements. Low-code solutions typically make code under-the-hood accessible and portable, too. Degrees here vary. Some, such as some-code, are more geared toward alleviating operational tasks for skilled engineers.

    Low-code solutions also may assist with the surrounding operations necessary to create a fully functional app, such as hosting, deployment and monitoring. Example providers in the low-code spectrum include Appian, Claris Filemaker, Mendix, Outsystems, Quick Base and Salesforce Lightning.

    No-Code

    No-code is like a driverless car

    In an automated car, AI handles all. Driving through traffic and re-routing is automated. You don’t need your hands on the wheel—but you do need a destination. Similarly, no-code is the most usable, non-tech option for application development. No-code is geared toward citizen developers and non-tech users.

    No-code takes low-code usability to a new level—100% UI-driven, with pre-built templates and the ability to string together utilities. No-code is popular in connectivity and triggers, taking the burden out of integration. Of course, the more you automate, the more granular control you sacrifice. Many no-code options simply require logins and permissions for business applications you already use. Examples include Zapier, IFTTT, Kissflow, Airtable and Retool.

    The trend toward low-code and no-code is industry-agnostic, too, having seen adoption by banking, manufacturing, consumer goods, eCommerce, and other areas, Kharade said.

    5 Common Low-Code Scenarios

    Now that we understand the variants, what are enterprises building using low-code? Kharade sees four common scenarios:

    1. Building internal forms: Collecting data in a form, such as for an inspection or audit. May require PDF generation. Non-tech folks with an understanding of their industry could create forms.
    2. Extending with publicly available forms: Making the form public for registration or lead generation. Requires little added functionality and a no-code user could likely implement.
    3. Working with databases: Junior engineers will readily understand database mechanics, but it’s not entirely non-tech, said Kharade. For example, skills may be required to synchronize databases with other cloud operations.
    4. Business process management (BPM): Digitizing the traditional corporate project approval processes. What was once paper-based or email-based is streamlined. It could involve picking up an order, pushing to a manager and a manager approves. Digitizing this process requires a deep understanding of the data structure.
    5. Purely open applications: Perhaps used for onboarding or internal job postings. Requires a fuller amount of user interaction design, workflows, file hosting and API connectivity. May require skilled developers.

    “Building your data structure at the start is extremely critical,” Kharade said. To him, more complex projects will still likely require skilled engineers at some point. But, as you can see above, there are many areas where low-code and no-code could streamline the creation of simple apps and tools.

    Low-Code, Demystified

    In other pieces, I’ve attributed the rise of low-code to an ongoing developer drought and the emergence of a digital-first economy during COVID. Throughout the pandemic, “there has been a frenzy to digitize any manual process,” noted Kharade. “People are scared even to use a pen someone has used.”

    Low-code has in part become a critical option to stand up replacement business applications rather effortlessly, providing citizen developers or non-tech users new digital capabilities. With its surge in popularity, the marketing language around this area is a bit befuddling, and many applications claim to be low-code or codeless.

    Of course, you could call any tool with a UI “no-code.” Technically, your iPhone apps are codeless from a user’s point of view. However, what sets these low-code development styles apart is their use in forging internal business applications and automating repetitive software development tasks. By utilizing low-code, traditionally non-tech companies could wrap operational capabilities around basic applications and scale them like tech companies.

    Another key to low-code, which I will expand on in a follow-up piece, is solving the integration hurdle with third-party APIs. “It’s difficult for a non-tech user to register an API,” Kharade said. One must understand authentication, OAuth, payloads, HTTP methods, responses and headers just to make a single call.

    API-driven services have needed better usability for quite some time. Low-code layers could make consuming a vast array of SaaS more inclusive—a fascinating prospect to problem-solvers of all skillsets.

  • How To Foster a Culture of Citizen Developers

    How To Foster a Culture of Citizen Developers

    What can leaders do to encourage a thriving environment of citizen developers in their organization?

    Over the last several months, businesses of all sizes have had to embrace rapid change, as have their workforces. When it comes to IT departments, even before the pandemic many were fielding requests to implement new technology, customize solutions to niche problems and automate specific tasks at rapid rates. Unfortunately, these increased demands coincide with an ongoing developer drought, and paired with the pandemic, have put an added strain on some already thinly stretched IT teams.

    As a result, there has been an observable rise in citizen developers being tapped to relieve some of this burden. “Citizen developer” here is used to describe any programming novice or non-developer who has been tasked with the responsibility of constructing custom applications. This person has some familiarity with programming but may not have been formally trained and, therefore, may use their own set of tools and workarounds to complete the work. If leaders don’t make an effort to create standardization, the consequence can be high variability in quality, efficiency and output.

    And it doesn’t seem to be a passing phase. I recently spoke with Dave Garrett, chief strategy and growth officer at Project Management Institute. As we look to the future, Garrett believes that citizen developers will play a critical role in helping organizations stay agile and ensuring projects move forward without delay.

    Though it won’t solve all of your pressing technical concerns, the good news is that with smart strategies, a citizen development emphasis can ease the burden on IT teams and improve output. Garrett spoke to a sea change of new techniques being developed to respond to these growing needs.

    4 Elements of Strong Citizen Developers Culture

    1. Standard Toolsets

    To start, build a solid foundation by choosing standard toolsets. Be sure all development staff is made aware of the toolsets you’ve deemed standard, clarify that adopting them is a priority and ensure that all have access. Standard approaches to using these tools should also be established and communicated, such as programming languages and stylistic standards.

    “If you have a standard toolset and approach, then you have many people who can help,” Garrett said, emphasizing that by doing so, you are building a broader base of support. Having a larger pool of employees to pull from helps an organization stay on top of the necessary tasks and creates more freedom for open collaboration. As a bonus, professional developers are freed to focus on more advanced tasks, such as machine learning and or mathematically complex programming.

    In deciding which toolsets and approaches to make standard, Garrett said, ask yourself, What will get them from A to B most quickly and efficiently? One approach to this is low-code or no-code tools. He considers such platforms transformational in empowering citizen developers to express ideas tangibly without a great deal of coding.

    2. Technical Training

    From here, ensure that all development staff, especially your citizen developers, have been technically trained in adopting the standard toolsets and approaches that have now been established. This may include offering training in low-code UIs and instilling fundamental programming concepts such as boolean logic and conditional programming such as If/Then/Else statements.

    “Set a foundation of success for learners,” he said. For example, have them build something of value during training, making it as actionable as possible for the use cases they will be handling.

    3. Discouraging Use of Shadow IT

    Once you have established toolsets and training, leadership should do whatever’s possible to enforce the established standard’s adoption and discourage the use of shadow IT—tools, applications and workarounds not approved by leadership within the company. Shadow IT, as a practice, can be messy, creating high variability and making quality-control and collaboration difficult. “You want to avoid it,” Garrett said.

    4. Good Mentorship and Governance

    Another benefit of having a standard toolset and eliminating shadow IT use is that it enables more efficient mentorship—critical for inspiring citizen developers. IT teams are advised to identify a mentor or group of mentors proficient with the standard tools to offer ongoing guidance to the team’s citizen developers.

    Quality mentorship goes hand in hand with quality governance. “Governance” here is used to mean technical admins who enforce the use of technical standards, tools and programming styles. No-code tools require access control that reflects a citizen developer’s permissions.

    Building in Hyper Agility + The Two-Pizza Rule 🍕🍕

    One way to think, Garrett said, is hyper agile. This can apply to team size, smart PM cycle lengths and brainstorming techniques.

    Team Size

    In thinking of ideal team size, ask: How can the team be optimized to work quickly and efficiently? One suggestion Garrett had was to ensure your team isn’t too large to effectively train, mentor and govern. For example, as a rule of thumb, he mentioned the old “two pizzas” rule: A team size shouldn’t require more than two pizzas to share a meal.

    Sigh. Remember things like in-person training? Pizza parties? Obviously, old meetups can’t be executed exactly to plan these days, except with some clever contactless delivery tactics, but you get the idea. A strategically sized team will create an efficient workflow and collaboration in your team dynamics.

    Cycle Length

    As projects come in, an agile cycle length, or sprint, for completing a specific set of work should be determined. What is an efficient amount of time to expect a team to turn out a project? To determine this, sprints should start with a planning meeting during which the product owner defines the work criteria. The development team determines a realistic time frame to complete the work scope. The scrum master or team manager typically makes this call.

    The lengths of agile sprints can vary—some may be two weeks, while others may be 30 days—depending on the scope of work. Most project management experts recommend you aim to keep your cycle length consistent, so teams get used to working within a set amount of time.

    Brainstorming

    Bringing attention to how your team ideates together is an excellent way to build agile collaboration. Brainstorming as a development team fosters collaboration and allows you to aggregate the talent and pull ideas together for the best output, whether you’re trying to solve a niche problem or simply join forces around how best to complete the sprint.

    Garrett recommended bringing people together in smaller groups for round-robin brainstorms and creating as you’re ideating. “Thus, iterations happen fast,” and all team members are given a chance to express their ideas in a tangible way.

    Once citizen developers see success, you can then use the excitement of building applications and solutions together to drive things forward, he said. Your anchor is a cool product that gets people excited—great for both morality and high-quality output.

    When Are Citizen Developers Appropriate?

    The question should be asked: When is it appropriate to call on citizen developers? Garrett recommended performing a suitability assessment to identify the best use cases for citizen developers. This will help the organization understand when it’s smartest to bring them in.

    The easiest way to answer this may be to consider: When isn’t it appropriate? Assigning advanced processes to citizen developers such as algorithm-heavy, mathematically complex programming or core product functionality is usually inappropriate, he said. Instead, utilize citizen developer talent for constructing internal business utilities that can be automated easily.

    There are formal suitability assessment tools that look at scores and attributes for applications to help you make this call. “However, everyone’s different,” Garrett noted. “You have your own ways of working, given context, goals and what you’re trying to accomplish.” So it may make the most sense to perform your own internal suitability assessment.

    Do the Numbers

    According to a recent PMI report, over the past five years half of organizations have recognized team members who brought innovative ideas forward, but:

    • Only 25% required dedicated time for innovative thinking and idea generation.
    • Only 19% hosted a creativity lab or hackathon facilitated by a professional.

    By contrast, their research shows that those promoting innovative practices see stronger results. Case in point:

    • 80% of organizations that encourage project leaders to expand their role have invested in at least one innovative idea in the past five years.

    The trend PMI sees on this front is that organizations want to innovate, but don’t always know how to make it happen. So, how might they push innovation forward? If you can implement a strong citizen development toolset, you can “enable innovation to bubble up,” Garrett said. The hope is this guide offers a blueprint for fostering just that.

  • 5 Steps to Avoid Shadow IT Around Low-Code

    5 Steps to Avoid Shadow IT Around Low-Code

    Shadow IT is far more pervasive than most CIOs think. Cisco Systems estimates that a typical firm has 15 to 22 times more cloud applications than authorized by the IT department.

    While shadow IT solves problems in the short-term for a select few, undocumented software ultimately encourages tribal thinking and siloed departments. This can stunt reusability, slow down new developer onboarding and lead to insecure points of failure—all antitheses to a DevOps culture.

    Simultaneously, new low-code tools are emerging that promise to reduce the programming burden from developers and enable citizen developers to create business applications on their own. But what happens when advanced users know better? Perhaps they’d rather code a quick function in Python or use another framework they’re more familiar with. If not properly governed, low-code platforms could easily be circumvented and lead to shadow IT.

    As many tech leaders can attest to, enforcing companywide standards can be tricky. I recently chatted with Jay Jamison of Quick Base to see what tactics organizations should take to avoid shadow IT when introducing low-code tooling. Here are five general tips CIOs can apply to reap low-code benefits while curbing shadow IT.

    1. Earn Developer Trust

    Focus on integration and open backends to earn developer respect

    Want to win the hearts of developers? Focus on integration. Many engineers don’t care about a shiny user interface and would rather interact with data models programmatically. As I’ve covered before, open API access is the secret sauce for low-code platforms.

    Choose a low-code platform that provides high-performant and secure RESTful APIs that use JSON. With open access to data models and low-level mechanics, advanced developers will feel less inclined to subvert the platform. What’s great about HTTP APIs is that they’re agnostic, so developers can interact with them from whatever language or environment they’re comfortable with.

    2. Govern and Set Permissions

    Establish access management policies with fine-grained permissions

    To avoid the emergence of shadow IT, software leaders must apply governance over data models, users and application privileges. These permissions should be fine-grained, to the field level. To do so, managers require an application lifecycle management functionality to edit these permissions. Such a governance layer would grant “tremendous power and control to IT and the business,” said Jamison.

    On low-code governance patterns, Jamison notices companies often lean toward one of two extremes:

    1. IT-centric: IT is leading the software models and only IT users can make changes.
    2. Operation-centric: IT acts as a governance body and building is pushed into business domains.

    Selecting which model to use is often based on the organizational culture and individual team member capabilities, noted Jamison.

    3. Encourage Collaboration and Knowledge-Sharing

    Build an easy path from mock-up to production

    Companies adopt low-code tools because they require something “quick and adaptable.” Yet, getting different operating teams at the same table can be difficult. Without high-quality collaboration, low-code could introduce a bottleneck.

    “Many teams must come together,” Jamison said. “How will this be productized; how will the workflow be tracked?” Companies truly require an effective collaboration model if they are ever to regularize their data models and assign access roles.

    To get everyone on the same page, Jamison recommended starting with a mock-up everyone can use as a reference: “Create an online chart to map out workflows and stitch it together in a collaboration space.” Business strategies can create detailed plans, and then builders can transform this into a prototype.

    4. Document and Reuse

    Encourage departments to document processes and expose reusable tools

    If users are sharing documentation via Excel and email, you know something’s wrong. Undocumented software is unmanageable software. Jamison reinforced the need for a “control layer” to localize documentation and encourage platform-wide governance standards.

    “Like buildings in a cityscape, some apps are more significant than others,” Jamison said. CRM applications may be entirely purpose-built for niche settings, while others, such as a team registry application, could be reused across an entire corporation. Increasing tooling reusability, he noted, requires teaching and training of documentation and change management practices.

    5. Adopt a Platform-Based View

    Standardize on a single platform and embrace a low-code culture

    The more teams use low-code, the more they think on low-code terms. As teams become more proficient in low-code, their mindset becomes: “How can low-code solve that problem?”

    By adopting a platform-based view, low-code becomes a utility to drive consistent data flows and workflows. To achieve this, it’s probably best to standardize around a single, companywide low-code platform. Otherwise, you risk inviting more unstandardized practices.

    For example, Jamison described how a large-scale manufacturer operating hundreds of plants worldwide uses a low-code platform to audit all plants’ quality in real-time. Other traditional non-IT businesses with a global footprint could similarly return a net value from consolidation on a single low-code platform.

    Will Low-Code Increase Shadow IT?

    It’s difficult to enforce any new tool, and some users will inevitably circumvent standard processes. However, by demonstrating the benefits of shared collaboration and low-code creative potential, leaders could stem shadow IT and the adverse side effects therein.

    By talking their language and saving time, low-code tools could win developer faith and encourage platform use. In review, here are some other ways to avoid shadow IT side-stepping around low-code:

    • Show some-code: Win developer’s hearts by talking on their terms and opening up the hood.
    • Govern: Use a common data model and apply fine-grained security constraints.
    • Ignite discussion: Bring groups together for open knowledge forums.
    • Unite business and IT: Enable citizen developers to design mockups and builders to execute quickly.
    • Use the platform: With more low-code use comes more creative sparks.

    Ultimately, low-code won’t replace 100% of your programming needs (especially at software-oriented companies). Low-code should be viewed as a time-saver, not a talent replacer, Jamison said. Low-code enables developers to quickly assemble simple business applications, freeing them to devote more time to core competencies or advanced processes that are far more interesting, such as building machine learning models.

    Final Thoughts on Low-Code Transformation

    There are many forces driving the current low-code revolution. Major tech hubs lack developer talent and COVID-19 has accelerated digital disruption. In this economy, requirements for business processes are changing “by the hour,” said Jamison. “The awareness around low-code is increasing because the need for automation and more digital solutions is increasing.”

    As Jamison noted, many enterprises are undergoing a “dual-track digital transformation.” Companies are investing in expensive, broad-scope cloud technologies while still digitizing many manual processes. To Jamison, low-code is now imperative to meet both needs. Thus, it should be adopted with forethought for all potential use cases (and shadowy non-uses).

  • Low-Code: An Oasis During Developer Drought

    Low-Code: An Oasis During Developer Drought

    Key insights from Mendix’s 2020 Developer Drought Index

    You may have heard that Silicon Valley is in the midst of a developer drought. But the Valley is not alone; developer talent across the U.S. heartland has dried up. In fact, the top 10 U.S. counties with the highest developer demand per capita aren’t even in California.

    A recent report by Mendix identified new hiring hotspots and a changing U.S. map for tech talent. States in the U.S. heartland are actively seeking developer talent, though some are slow to adopt 100% remote work. In the wake of COVID–19, many are reassessing work-life opportunities, leaving densely populated cities to work and live in more rural areas.

    I recently had a great discussion with Sheryl Koenigsberg, head of global product marketing at Mendix, to make sense of the “Developer Demand Index” findings. Below we speculate on the future of developer work, and how low-code platforms may be the oasis many talent-thirsty companies seek.

    ‘Developer Demand Index’ Study

    The “Developer Demand Index” sought to identify locations where developer talent is needed the most. The process involved a geographic analysis of 2,000 of July 2020’s job ads for U.S. software developers.

    The study found high developer demand and short supply in middle America; South Dakota, Nebraska and Utah were among the top states with the lowest supply to demand.

    At a county level, the highest developer demand was in Cumberland County, New Jersey; Minnehaha County, South Dakota; and Pontotoc County, Mississippi.

    The study demonstrated how more established tech hubs—Silicon Valley and Austin, for example—have a better balance of talent demand and supply.

    “The study confirmed unpopular theories that I had,” said Koenigsberg. “Developer drought is not a Silicon Valley or coastal-only problem; smaller metros throughout the country are experiencing the same problem.”

    Conditions for a Drought

    Why do states in the nation’s heartland have a developer drought to begin with? I assumed that a lower average salary in middle America would deter developers, but Koenigsberg said the conditions are more complex.

    “I don’t necessarily see a correlation between average salary and developer drought,” she said. Rather, new tech hubs continue to form wherever larger enterprises can get tax breaks. Other regional perks could include local government startup incentives or university partnerships.

    Tech certainly has a history of revitalizing less dense areas with new hubs. Take Google’s expansion into Austin, Amazon’s takeover of Seattle’s South Lake Union neighborhood or SpaceX’s remote Starship site in Boca Chica, Texas. Naturally, these areas attract the requisite talent and encourage other companies into the fold as well.

    For example, the report speculates South Dakota state could be a new Silicon Prairie hotspot. “A vibrant tech & startup scene, local talent, and the lowest COVID–19 rates are all driving the economic surge in this state,” read the report.

    With remote work and social distancing brought on by COVID–19, technology companies are adapting and the urgency to cluster in certain locales may dissipate.

    COVID–19 and Remote Work

    Software was already eating the world. But with COVID–19, it’s eating physical reality itself.

    With COVID–19 forcing many companies 100% online, the need for new software is skyrocketing like never before. Google, Facebook and many others have enacted stay-at-home plans for most of 2021. After the crisis, remote work will be a more permanent reality for many.

    While COVID–19 benefited tech, many brick-and-mortar businesses were less prepared. We’re now seeing the frailties of old systems, described Koenigsberg, and the need to replace paper-based or manual operations with digitized versions. Consumer-facing companies that did not vigorously embrace digital transformation before COIVD–19 are now in a tight spot.

    Low-Code Waters Fill a Developer Drought

    According to Derek Roos, CEO of Mendix, “the ‘Developer Demand Index’ shows that companies need to think differently about how and where to engage skilled tech workers in 2021 and beyond. Traditional development paradigms basically fall apart when you’re dealing with mobile or remote workflows.”

    As I covered recently, COVID–19 is only one of many factors spurring a low-code revolution. By utilizing visual-based models, “citizen developers” can construct applications. This enables a business analyst, for example, to string together an internal application without jumping through the traditional IT hoops. Koenigsberg identifies other low-code benefits:

    • Hire Local: If tools are less impenetrable, companies can retrain local employees, helping recover the developer gap and negating the need to hire externally.
    • Collaboration: Low-code aids remote work, enabling pair programming where teams work on the same model simultaneously.
    • Domain Expertise: Citizen developers with niche domain knowledge can better optimize applications to their industry needs. Knowing a factory production yield, for example, can help better construct a manufacturing application.
    • Women in Tech: Koenigsberg notices significantly more female involvement at low-code themed events. Hopefully, low-code can have a balancing effect on gender participation in tech.

    Final Thoughts

    The Mendix “Developer Drought Index” revealed areas of high demand and short supply throughout the U.S. Interestingly, 92% of the job ads analyzed in the study required a specific location. Regardless, the report concludes there are compelling “opportunities for companies and individuals to decentralize talent away from established tech hubs using virtual teams and cloud technology.”

    Low-code seeks to democratize software development to keep deployments on pace with the intense demand for software. Of course, low-code is no cure-all, and Developer Drought locations will likely still seek external or offshore hiring to supplement. However, low-code may offer the respite needed during uncertain times.

  • Mendix Injects More AI to Accelerate Low-Code Development

    Mendix Injects More AI to Accelerate Low-Code Development

    The rate at which low-code applications are built and deployed will accelerate as developers begin to rely more on artificial intelligence (AI) to write code. The summer 2019 release of the Mendix low-code platform includes a revamped instance of Mendix Assist, which employs machine learning algorithms to make coding recommendations. Those algorithms have been trained using data drawn from 5 million application models employed across 15 industries over the last 10 years, and Mendix claims this version of Mendix Assist improves the accuracy rate of the recommendations being made to 95%.

    Sheryl Koenigsberg, director of product and solutions marketing for Mendix, said Mendix Assist will enable new developers to write better code faster, while experienced developers will be able to employ Mendix Assist to address routine issues that often get overlooked faster. Mendix Assist not only advises developers on what to do next but also generates recommended actions in previous logical steps based on whatever new code is introduced in the application.

    Mendix

    To make these capabilities more accessible, the summer release of Mendix adds Mendix Studio and Studio Pro, a set of integrated development environments designed to be accessible to both citizen and professional developers, to the low-code platform.

    In addition, Mendix is adding support for native mobile application development by adding support for React, a set of JavaScript libraries for building user interfaces for mobile applications, and including a native JavaScript editor. Those capabilities eliminate the need to rely on emulation software when building mobile computing applications, said Koenigsberg. Because the Mendix IDEs integrate low-code abstraction across iOS, Android, Java and Objective-C programming models, it also becomes easier for mobile developers to build reusable components. Mendix has also included more than 50 pre-built connectors to mobile device capabilities, such as camera, geolocation, biometric authentication and Bluetooth enablement, along with support for conversational chatbots and voice interfaces such as Alexa and Siri.

    Longer-term, Koenigsberg observed that it’s conceivable the AI capabilities being included in application development tools eventually will share insights with AI models being incorporated into continuous integration/continuous deployment (CI/CD) platforms. Proposed changes to an application could, for example, might be assessed from a performance perspective before any lines of code are written.

    In the meantime, the rate at which low-code applications will be moving through CI/CD platforms is about to increase substantially as developers augment their own skills by relying more on recommendations surfaced by AI engines. The quality of those applications should also improve as AI engines check, for example, to make sure all the appropriate compliance and cybersecurity controls are in place.

    It’s not likely AI engines will replace the need for developers anytime soon. However, it is apparent all the little things that routinely conspire to slow application development and delivery processes increasingly will be automated. That should make it easier for a larger number of organizations to embrace best DevOps processes. After all, the primary issue with DevOps adoption these days is not necessarily appreciating the value of the concept, but rather managing pipelines that still tend to get clogged every time an application fails to pass a gate because a developer forgot to do one thing or another.

    — Mike Vizard

  • Low-Code Has Taken Development by Storm. Why Not the Web?

    Low-Code Has Taken Development by Storm. Why Not the Web?

    For more than a decade, development tools increasingly have made their way into the hands of less-technical people. On the web in particular, we’ve eliminated the webmaster as the middleman with content management systems and moved progressively toward a model where non-technical users could assemble their own sites with little to no coding experience of their own.

    Fast forward and today, the terms “no-code” and “low-code” are used to describe this idea. Furthermore, no-code and low-code tools have been on a decade-long rise, with an increasing impact on the web. Examples include:

    While this has been a strong, decade-long market trend, we’re only at the beginning. This trend won’t stop until new website experiences are automatically generated and optimized by machine learning.

    Trends Driving the Low-Code and No-Code Movements

    According to Wave, “In our survey of global developers, 23% reported using low-code platforms in 2018, and another 22% planned to do so within a year.”

    Major market forces driving this trend include a talent shortage among developers, with an estimated 1 million computer programming jobs expected to remain unfilled by 2020 in the U.S. alone. What’s more, the developers who are employed are often overloaded with work and struggle with how to prioritize it all. Some of this burden could be removed by low-code and no-code tools, allowing marketers and other non-technical professionals to do some of the development work themselves. In addition, the fact that technology has permeated every aspect of our lives, from our smartphones to our smart homes, has driven the need for more people to become creators.

    “As creating things on the internet becomes more accessible, more people will become makers. It’s no longer limited to the <1% of engineers that can code, resulting in an explosion of ideas from all kinds of people,” said Ryan Hoover, founder of Product Hunt, in a blog post.

    In other words, the supply of web creators must keep up with the demand for more digital experiences across more channels.

    But this does not only apply to individuals. Consider this: The typical large organization has to build and maintain hundreds of sites. These organizations need to build, launch and customize sites in days or weeks, not months. Today and in the future, marketers and other non-technical stakeholders can embrace no-code and low-code tools to develop websites rapidly.

    Abstraction Drives Innovation

    As predicted in my middleman blog post, developers won’t go away. Just as the role of the original webmaster has evolved with the advent of the CMS, the role of web developers is changing with the rise of low-code and no-code tools.

    Today, developers tend to focus on creating next-generation digital experiences that require new and emerging technologies not yet available in no-code solutions. In the process, they help invent and build new technologies such as React, Vue.js, etc.

    Successful no-code approaches abstract away complexity for web development. This enables less-technical people to do things that previously only could be done by developers. When those abstractions happen, developers can move on to the next area of innovation.

    Such abstractions are a good thing for both developers and non-technical website creators. When everyone is a builder, more good things will happen on the web. I was excited about this trend more than 12 years ago and remain excited today. I’m eager to see the progress no-code and low-code solutions will bring to the digital world in the next decade.

    — Dries Buytaret