devopsy.kinsta.cloud

Category: Continuous Delivery

Continuous delivery is a software engineering discipline that allows organizations to consistently develop and release quality software at a rapid pace. It is achieved by automating the software development lifecycle, enabling tasks such as development, testing and release to occur concurrently and continuously.

  • How Can DevOps Teams Use Customer Intelligence Data?

    How Can DevOps Teams Use Customer Intelligence Data?

    Customer intelligence involves collecting and analyzing data about customers’ behaviors, preferences and needs. It helps businesses understand their customers better and tailor their products and services to meet customer demands. The data is gathered from various sources, such as customer feedback, web analytics, social media, purchase history and software usage metrics. The insights drawn from customer intelligence can be used to inform business strategy, product development and marketing efforts.

    The goal of customer intelligence is to create a detailed understanding of the customer’s needs, preferences and habits. This information can be used to predict future behavior, improve customer service and drive sales. For instance, if a software company knows that a particular customer segment mainly accesses their software on mobile devices, the organization can improve their mobile support or create dedicated mobile applications for that customer segment.

    How Can DevOps Teams Use Customer Intelligence Data?

    There are several ways that a DevOps team can leverage the data gathered from customer intelligence.

    Prioritizing Feature Development Based on Customer Feedback

    When developing new features, it’s useful to analyze customer feedback to understand what features customers find most valuable and prioritize those for development. For instance, if feedback suggests that customers want a more intuitive user interface, the team can prioritize UI improvements.

    By focusing on the features that customers find most valuable, DevOps teams can improve the usability and functionality of their products. This can lead to higher customer satisfaction and loyalty and, ultimately, increased sales. Additionally, prioritizing feature development based on customer feedback can help DevOps teams avoid wasting time and resources on features that customers don’t value.

    Tailoring UX and UI Design Based on Customer Preferences and Behaviors

    By analyzing data on how customers interact with their products, teams can identify pain points and areas for improvement. For example, if data shows that customers are having difficulty navigating the website, the team can redesign the navigation to make it more user-friendly. 

    Alternatively, if customers abandon their shopping carts at a certain point in the checkout process, the team can investigate and make necessary improvements.

    Using Customer Data to Drive Personalization and Customization Features

    Personalization is about tailoring the customer experience to the individual user, while customization is about giving customers the ability to tailor the product or service to their specific needs.

    For instance, by analyzing data on a customer’s browsing and purchase history, a team could develop a feature that recommends products based on the customer’s past behavior. Or, if a customer frequently purchases a certain type of product, the team could create a feature that allows the customer to customize that product to their liking.

    Leveraging Predictive Analytics to Forecast Future Customer Needs and Trends

    Predictive analytics involves using historical data to predict future events. In the context of DevOps, this could mean using customer data to forecast future customer needs and trends.

    For example, if data shows a growing interest in eco-friendly products, the team could anticipate this trend and start developing more eco-friendly products. Predictive analytics can also help teams identify potential issues before they become problems, allowing them to address those issues and improve the customer experience proactively.

    Best Practices for Effectively Using Customer Intelligence in DevOps

    Here are some best practices that DevOps teams can use to make the most of their customer intelligence data.

    Integrate Customer Feedback Early and Often

    Customer feedback from surveys, social media, and customer service interactions provides invaluable insights into what customers need, their pain points, and their preferences.

    By integrating this feedback into the DevOps process, teams can better understand customer needs and develop products or services that address those needs effectively. Early integration of customer feedback allows teams to pivot and make changes more swiftly, thus saving time and resources.

    It’s also important to obtain feedback regularly. Customers’ tastes and preferences evolve continuously, and their feedback reflects those changes. Feeding frequent customer intelligence into the development process ensures the DevOps team’s work stays aligned with the shifting customer landscape.

    Leverage Analytics Tools

    Analytics tools can help DevOps teams sift through large volumes of customer data and extract actionable insights. These insights can then be used to inform decision-making and drive innovation.

    Some tools excel at data visualization, helping teams understand complex datasets through graphs and charts. Other tools excel at predictive analytics, helping teams forecast future trends based on historical data.

    Choosing the right analytics tool depends on the specific needs of the DevOps team and the nature of the customer intelligence data they have at their disposal. The key is to leverage its capabilities fully to extract the most value from the customer intelligence data.

    Ensure Data Quality and Relevance

    Not all data is created equal, and if it is poor quality or irrelevant, it can lead to misguided decisions and wasted resources.

    Data quality refers to the accuracy, completeness, consistency, and reliability of the data. DevOps teams should implement robust data quality checks to ensure that the customer intelligence data they’re using is of high quality.

    Data relevance, on the other hand, refers to the data’s applicability to the task at hand. Not all customer intelligence data is relevant to every DevOps project. Teams need to carefully select the data that is most relevant to their specific project and ignore the rest.

    Balance Quantitative with Qualitative Data

    While quantitative data provides hard numbers and concrete facts, qualitative data offers deeper insights into customer attitudes, perceptions and behaviors.

    Quantitative data can help DevOps teams identify trends, measure performance, and track progress over time. However, it often fails to explain why certain trends are occurring or why performance is changing. 

    It also can help DevOps teams understand the reasons behind the numbers. It can provide insights into why customers behave the way they do and what they truly think and feel about a product or service. Balancing quantitative with qualitative data gives DevOps teams a more holistic view of the customer landscape, enabling them to make more informed decisions.

    Cross-Functional Collaboration

    Customer intelligence data is valuable for all teams across the organization, not just DevOps. By collaborating with other teams, such as marketing, sales and customer service, the DevOps team can gain additional insights and perspectives. 

    Cross-functional collaboration also fosters a culture of data-driven decision-making across the organization. When all teams use customer intelligence to inform their work, the organization as a whole becomes more customer-centric, agile and innovative.

    Conclusion

    Successfully using customer intelligence data in software development allows teams to remain responsive to customer needs and increase the value of their products. DevOps teams need to integrate customer feedback early and often, leverage analytics tools, ensure data quality and relevance, balance quantitative with qualitative data,and foster cross-functional collaboration. By following these best practices, DevOps teams can use customer intelligence data to drive innovation and create products and services that truly resonate with customers.

    Image source: Josh Sortino via Unsplash  

  • API Management: A Weak Link in the Cloud-Native Chain

    API Management: A Weak Link in the Cloud-Native Chain

    Managing APIs is like navigating unfamiliar terrain during a road trip: There’s an old way and a new way to do it, and the new way is just better in many cases. For API management, the old way of doing things involves practices like writing proprietary scripts, manual transaction monitoring and relying on individual employees to take charge of managing specific APIs – leading to more manual work, slower release processes, slower incident recovery and lower reliability. It’s akin to navigating a highway using a paper map, stopping at gas stations to ask for directions and crossing your fingers that you end up at your intended destination.

    The new way of managing APIs looks like this: Using declarative configurations, automated processes and stateless APIs, teams scale and centralize the tasks of configuring, monitoring and updating APIs. They also deploy API changes several times a day, and they can instantly mitigate incidents in production.

    It’s like navigating with a GPS: A simpler, faster and more flexible approach that gets you where you want to go with much less hassle and risk.

    To prove the point, allow me to walk through the reasons why traditional API management strategies fall short for modern environments, then discuss what it takes to manage APIs better.

    What is API Management?

    Let me begin by defining what I mean by API management.

    I’m referring to all of the practices, processes and tools that businesses use to support the APIs their workloads depend on. API management encompasses API design, development, monitoring, testing and security, as well as making updates to APIs after they are in production.

    These tasks are important, of course, because APIs are everywhere today. They handle 83% of internet requests, according to Akamai, which means that keeping APIs documented, updated and monitored is a critical requirement for virtually any organization that deploys Internet-connected applications.

    Without an efficient and scalable means of managing APIs, it becomes difficult not just to defend against challenges like security risks involving APIs but also to guarantee a positive developer experience. The more time and toil your developers have to invest in API management, the less time they have to do the things they want to do and that matter most to the business – like developing cool apps and bringing them to market.

    The Pitfalls of Traditional API Management

    APIs are not new, and most teams that support them have long had API management practices in place. However, in many cases, those practices were conceived in the era when monolithic application architectures and bare-metal servers or virtual machines dominated the IT landscape. They weren’t designed for today’s cloud-native, software-defined, distributed-everything world.

    As a result, traditional API management falls short in modern environments in several key respects:

    ● Slow change management: When you are continuously pushing out updates to apps and APIs, you need an API management strategy that can handle continuous change. Traditional approaches can’t do this. They are too human-intensive to keep pace with rapid change.
    ● Lack of reliability: If you manage API configurations manually, you face a higher risk of introducing changes that accidentally break something. And if that happens, fixing the issue is slow because you have to reconfigure everything by hand.
    ● Slow recovery speed: When you experience an incident related to an API – such as a latency increase due to a misconfigured API – recovery is slower because it’s difficult to trace the surface-level problem back to its root cause, given the lack of a central source of truth for tracking the API’s status and revisions.
    ● Lack of scalability: Traditional API management uses imperative configurations that are stored in stateful databases, which have to be provisioned for each API you want to deploy. That works if you have just a handful of APIs to manage, but it’s impossible to scale if you need to scale to support dozens or hundreds. It also creates particular challenges if you have geo-distributed teams and infrastructure.
    ● Lack of modularity: Conventional API management architectures are not modular or composable, making it difficult to reuse configuration components between APIs. Instead, engineers are forced to “reinvent the wheel” every time they need to configure a new API or move an existing one from dev/test to production.
    ● Lack of standardization: Traditional APIs typically depend on proprietary technologies. As a result, they’re difficult to integrate with modern stacks that are based on widely used tools like Kubernetes, OpenTelemetry and Git.
    ● Poor collaboration: Documenting APIs and sharing monitoring insights between teams is also challenging when configurations are imperative and there is no single source of truth that all stakeholders can refer to when tracking the status of an API.

    These challenges lead to a nightmare for teams tasked with Day 2 operations, meaning those that support APIs after they are in production. Slow, inefficient and unscalable management processes lead to struggles in detecting and fixing problems with API performance or security, as well as in updating APIs. And again, they hamper the developer experience by forcing developers to devote time and energy to deciphering APIs and versions to use, finding up-to-date documentation, and so on. As a result, developers whose main job is to write software, not manage APIs, become burdened by API management requirements.

    A Better Way to Manage APIs

    The good news is that a better world is possible – at least when it comes to API management. For modern apps and environments, API management should be rooted in the following principles:

    ● Composability: Your API management stack should be composable so that you can pick and choose from different ingress controllers, monitoring and analytics tools, load-testing solutions and so on. You shouldn’t be bound to a rigid, inflexible “stack.”
    ● Statelessness: Stateless API management, which frees APIs from dependency on stored configurations, enables scalability, simple rollbacks and consistency across environments because you can deploy APIs anywhere with minimal provisioning.
    ● Automation: The more you automate the processes involved in API management, the faster you can implement changes and the lower your risk of mistakes and inconsistencies due to manual management.
    ● Immutability: The underlying infrastructure that powers your API management stack should be immutable so you can replicate it easily and quickly – a benefit during processes like troubleshooting following a rollback.
    ● Auditability: You should be able to maintain a timestamped log of every change to your API that documents when changes are made, who made them, why they happened and what the potential implications are.
    ● Open and standards-based: The ability to monitor and manage APIs using open, standardized tools and frameworks – such as OpenTelemetry and kubectl – also leads to consistency and simplifies collaboration between teams. In addition, API contracts should be standardized using specifications like OAS.
    ● Efficient incident response: When you discover a performance problem or failure linked to an API, you should be able to troubleshoot and resolve the issue quickly without having to chase down documentation or find the one person at your company who understands how the API works.

    When you manage APIs according to these principles, you escape the tedium and inefficiency of traditional API management. By extension, you can easily support the many APIs that tie your cloud-native environments together.

    The Role of GitOps

    Going a step further, a declarative, stateless, automated approach to API management also enables GitOps, meaning that you can manage APIs via declarative configurations that you store in Git repositories.

    This practice also leads to greater reliability (thanks to consistent, repeatable and scalable configurations), collaboration (because Git serves as a shared, central source of truth for API configurations and workflows) and efficiency (due to the ability to automate and customize deployments using Git-based triggers and actions).

    Conclusion: API Management at Cloud-Native Speed

    In a world where more than half of existing applications are cloud-native and a majority of new apps will leverage cloud-native principles, traditional API management just doesn’t work for these new platforms. It leads to change management processes that are slow and unreliable – exactly the opposite of what businesses need to thrive in a dynamic, cloud-native world. It also slows down recovery, leading to lower levels of reliability and higher risk for the organization. On top of this, it’s tedious, inefficient and unscalable. So yes, cloud-native API management is currently broken.

    We need a radical new approach to API management with one goal in mind: Automate Day 2 API operations with a modern approach. Modern solutions should be rooted in stateless, declarative configurations, open standards and Git-based automation. They must enable change management with high reliability and instant recovery, so you don’t have to worry about API management becoming the weakest link in your ability to innovate quickly and with minimal risk.

    We envision a new world where managing APIs is no longer a burden that developers and platform teams must bear but instead a process that helps teams innovate as quickly as possible, no matter how complex the API architectures they are working with. We also want to help businesses bring products to market faster, as well as troubleshoot incidents more quickly and with less effort.

    Ultimately, we want to empower organizations to take full advantage of cloud-native technologies and paradigms by adopting a cloud-native approach to API management.

  • F5 Looks to Streamline Application Networking

    F5 Looks to Streamline Application Networking

    At its AppWorld 2024 conference this week, F5 announced a software-as-a-service (SaaS) edition of its NGINX application networking portfolio, which are now all available under a single enterprise license.

    Shawn Wormke, general manager for NGINX, said NGINX One will eliminate much of the friction enterprise IT teams currently encounter when implementing NGINX Plus, NGINX Open Source, NGINX Unit, NGINX Gateway Fabric and the Kubernetes Ingress Controller the company provides.

    As part of that effort, F5 is also now making available a unified console across its application networking portfolio that promises to streamline the management of the F5 application networking portfolio.

    Currently available under an early access program, NGINX One creates an as-a-service platform through which enterprise IT organizations can invoke and pay for these capabilities on an as-needed basis, said Wormke. The overall goal is to reduce the total cost of application networking by eliminating the need for IT teams to integrate the various elements of NGINX One on their own, he added.

    In general, application networking has become more complex with the rise of cloud-native applications based on microservices. By reducing the cognitive load required to network those applications, it becomes simpler to make network operations a more natural extension of DevOps workflows, noted Wormke.

    Most organizations have some level of experience with application networking using proxy servers, but as application environments have become more complex, the need for gateways and ingress controllers to provide these capabilities at scale has become more apparent. As a result, more IT organizations are starting to revisit how they are structured. There may always be a need for dedicated networking specialists to manage the physical network underlay, but as other networking services become more integrated with DevOps workflows, responsibility for some networking services is starting to shift further left toward DevOps teams that will either deploy these capabilities themselves or take advantage of a SaaS platform such as NGINX One. The overall goal is to be able to dynamically provision application networking services without having to wait for a network administrator to provision them.

    There are, of course, a lot of approaches to application networking that are now emerging. Regardless of how application networking evolves, however, the rigidity that has characterized the delivery of network services for decades should finally start to fade away. Today, outside of a cloud computing environment, it’s still common for IT teams to provision virtual machines or Kubernetes pods in hours only to wait days or even weeks for network connectivity to be provisioned. As IT environments become more hybrid and more workloads are pushed to the edge, there is a clear need for a more agile approach.

    Each organization will need to decide how best to approach application networking across legacy monolithic applications, microservices and event-driven applications at a time when IT environments have become much more complex to manage. The challenge, as always, is reducing as much friction as possible without unduly raising the total cost of IT to a point where it becomes unsustainable.

  • Survey Surfaces Raft of Ongoing Agile Development Challenges

    Survey Surfaces Raft of Ongoing Agile Development Challenges

    A survey of 788 software development professionals finds 71% are using agile development methodologies within their software development life cycle (SDLC) but only 44% said it is working very well (11%) or somewhat well (33%) in the enterprise.

    Conducted by Digital.ai, the survey identifies end-to-end visibility and traceability from business initiative through deployment as the top opportunity for improvement (44%), followed by an ability to measure cycle time, wait time and bottlenecks (34%), continuous testing (29%) and identification and measurement of technological risk (28%).

    Nearly half (46%) identified too many systems as a primary reason Agile was not scaling, followed by siloed teams (37%), culture clash (34%), inconsistent adoption (30%) and the inability to measure business value (28%).

    Despite these issues, nearly two-thirds (63%) said they have visibility into their Agile pipeline, with 55% claiming they have complete visibility. However, only 36% said DevOps teams currently work together as one team to accelerate innovation and deployment of high-quality and more reliable software. At the same time, only two-thirds (66%) claimed at least 50% of their applications were delivered on time and “with quality.”

    Joyce Tompsett, general manager of the State of Agile project at Digital.ai, said the survey makes it clear many organizations are still trying to strike the right balance when it comes to developing software. For example, the survey finds the top two reasons organizations adopt Agile (tied at 41%) are to accelerate time to market and prioritize delivery and measure customer/business value. Most software development teams are being evaluated both based on velocity (33%) and the value delivered (29%), the survey finds.

    The survey also identifies customer satisfaction (43%), time to delivery (39%) and competitive advantage (34%) as their top priorities for 2024.

    In general, the survey finds that 33% of respondents reported business leaders and executives are actively leading and participating in company-wide agile transformation. However, more (41%) said there was not enough leadership participation. Well over a third (37%) said business teams simply don’t understand what Agile is or what it can do. More than a quarter (27%) said there is not enough training.

    Not surprisingly, the most widely adopted methodology is Scrum (63%) with the Scaled Agile Framework (SAFe) being the most widely used (26%). Another 22% don’t have a mandated framework, while 12% said they have created their own.

    The debate over what precisely constitutes agile development is, of course, ongoing. Each organization tends to adopt the elements of the framework that make the most sense for them, so the actual state of adoption from one organization to the next will vary widely. The one thing that is certain is the more complex the IT environment, the more challenging it can be to embrace agile development.

    And there continues to be lots of room for improvement. If only two-thirds of organizations are delivering half (50%) of their applications on time with an acceptable level of quality, it means there are more projects that are failing to meet that standard than many software development teams might care to admit.

    As more organizations become more dependent on software, however, tolerance for that level of failure will only continue to decline as businesses and leaders lose patience with application development practices that do not live up to expectations.

  • OpenText Extends Tool for Auditing Source Code Using Machine Learning

    OpenText Extends Tool for Auditing Source Code Using Machine Learning

    OpenText this week updated a static analysis tool it provides to audit code using machine learning algorithms to provide deeper insights into on-premises IT environments.

    Announced at the OpenText Security Summit 2024 conference, the latest generation of Fortify Audit provides additional artificial intelligence (AI) models capable of learning the unique attributes of custom source code.

    The latest version of Fortify Audit Assistant also adds the ability to detect drift in a model and, if necessary, automatically refresh it. OpenText is now committing to refreshing those models every quarter.

    The discriminant AI model from OpenText enables machine learning algorithms to learn how humans conducted an application audit to then run similar tests on other applications. Previously, Fortify Audit relied on the same core model to audit both on-premises and software-as-a-service (SaaS) applications based on data collected by OpenText. Fortify Audit Assistant now provides support for more than 30 language-specific models to improve testing performance.

    Dylan Thomas, senior director for Fortify engineering and product for OpenText Cybersecurity, said this capability ensures that any sensitive data never leaves an on-premises IT environment.

    The overall goal is to streamline the number of alerts that would otherwise overwhelm a DevSecOps team trying to identify the root cause of an issue, he added. For example, Fortify Audit Assistant will identify test code that is not vulnerable because it was never deployed in an actual production environment. That approach makes it easier for DevOps teams to prioritize which vulnerabilities to fix first in their source code using a lightweight AI model that still enables them to deeply scan source code, noted Thomas.

    Historically, DevSecOps teams need to make a trade-off between lightweight approaches and deep scans of source code that is no longer required, he added.

    As regulations pertaining to software supply chain security become more stringent the number of development teams that will be subject to some type of audit is only going to increase. The cost of failing an audit will also inevitably increase as regulatory bodies look to make examples of organizations that are not properly securing their software supply chains.

    It’s not clear how aggressively organizations are embracing best DevSecOps practices to address myriad software supply chain security issues that were highlighted in an executive order issued by the Biden administration to Federal agencies. However, with the rise of AI and other forms of automation, it should become simpler to identify more vulnerabilities before they wind up being exploited in a production environment.

    There will always, of course, be a need to secure production environments because there’s always a probability mistakes will be made. However, given the lax practices many organizations have employed to build and deploy applications, it’s probable the number of vulnerabilities that exist in production environments today is beyond counting. In many cases, the better part of valor might be to replace many of those applications entirely with ones built using DevSecOps best practices.

    Regardless of the path to better application security chose the one thing that is certain is cybercriminals are only going to become even more adept at discovering those vulnerabilities.

  • 10 Key Features of AI Code Assistants

    10 Key Features of AI Code Assistants

    One of the most potent tools that have emerged to streamline the coding process is code assistants. Code assistants are software tools designed to assist programmers by providing suggestions and automated features that help in writing code more efficiently and accurately. They act as virtual aides, making the coding process faster, more intuitive and less prone to errors.

    Code assistants can be categorized into two types: Rule-based and AI-based. Rule-based assistants follow predefined rules and perform according to set guidelines. They are mainly used for syntax highlighting, code formatting and basic error detection. AI-based code assistants can learn from past coding patterns, predict what a programmer is trying to achieve and suggest appropriate code snippets. They are capable of understanding the context of the code and providing accurate suggestions, as well as generating entire blocks of code based on natural language instructions. Read this blog post for examples of popular AI coding assistants.

    Whether you are an experienced software developer handling complex projects or a beginner, coding assistants can automate the tedious aspects of coding, allowing you to focus more on problem-solving and innovation.

    The Growing Importance of AI in Software Development

    As software development becomes more complex and time-sensitive, the role of AI in this field has grown significantly. AI-driven code assistants represent a major shift in how software is developed. They bridge the gap between human expertise and the efficiency of automated processes. 

    AI in software development not only speeds up the coding process but also enhances the quality of the code. These tools can analyze vast amounts of code, learn from it and apply that learning to assist developers in real-time. They can adapt to different coding styles and requirements, making them versatile tools for a wide range of programming tasks. Furthermore, as software projects increase in size and complexity, AI code assistants become crucial in managing and navigating these complexities. They offer intelligent insights, detect potential issues before they become problematic, and assist in keeping large codebases clean and manageable.

    In addition to increasing efficiency, AI code assistants are instrumental in reducing the barrier to entry in software development. They make coding more accessible to people with varying levels of expertise, including those who are new to programming. This accessibility is essential in an era where the demand for software development skills is continuously rising. By providing real-time assistance and learning resources, AI code assistants are not just tools for current developers but also learning aids for future generations of programmers.

    10 Key Features to Expect from Code Assistants in 2024

    With the rapid advances in large language models (LLMs), the following features are becoming standard in coding assistants as we enter 2024.

    Advanced Contextual Understanding

    Modern code assistants are evolving to understand the context of code more intricately. Unlike simple autocomplete tools, these AI systems can analyze the broader scope of a project, recognizing patterns and offering suggestions that align with the overall architecture and design patterns. This advanced understanding not only streamlines coding but also aids in maintaining consistency throughout the codebase.

    Real-Time Code Optimization Suggestions

    AI tools can proactively recommend changes to improve performance and efficiency. For instance, a code assistant might suggest a more efficient algorithm or highlight redundant code blocks that can be simplified. This feature not only enhances code quality but also serves as a learning tool for developers, exposing them to best practices and alternative approaches.

    Enhanced Debugging Assistance

    Debugging is often a time-consuming aspect of development. In 2024, expect code assistants to revolutionize this process by offering enhanced debugging assistance. Through deep analysis, these tools automatically detect errors and anomalies, suggesting potential fixes. They can pinpoint the exact location of a bug and provide context, significantly reducing the time developers spend in the debugging phase.

    Automated Refactoring

    Refactoring is crucial for maintaining clean code, and AI-driven assistants now offer sophisticated automated refactoring capabilities. They intelligently suggest changes that improve code readability and maintainability, such as restructuring code or renaming variables for clarity. These suggestions will be particularly beneficial for managing and updating legacy code, ensuring it adheres to modern coding standards.

    Code Documentation Generation and Update

    Keeping documentation updated is a challenge. Code assistants can now automate this task by generating and updating documentation in real-time. As code changes, the documentation will reflect these updates, ensuring that it always stays in sync with the codebase. This feature will be invaluable in large teams where keeping track of changes can be daunting.

    Predictive Coding Assistance

    Moving beyond reactive suggestions, code assistants will offer predictive assistance. By analyzing coding patterns and project structures, these tools will predict a developer’s next steps and offer relevant suggestions even before they are explicitly requested. This proactive approach will speed up the development process, reducing the cognitive load on developers.

    Understanding and Responding to Developer Queries in Natural Language

    Developers can pose queries or express coding requirements in plain English, and the assistant will interpret and execute these requests. Chat-based interfaces offered by leading AI coding assistants take this one step further. This advancement will make coding more intuitive and accessible, especially for beginners or non-expert users.

    Real-Time Suggestions and Conflict Resolution in Team Projects

    Collaboration in coding projects can lead to conflicts and inconsistencies. Code assistants now offer real-time suggestions and automated conflict resolution for team projects. These tools will identify potential conflicts in merge requests and suggest optimal resolutions, enhancing team collaboration and maintaining code integrity.

    Personalized Coding Assistance Based on Past Interactions

    Personalization is becoming a significant feature of code assistants. By learning from past interactions with a developer, these tools will tailor their suggestions and support to align with individual coding styles and preferences. This adaptive learning approach ensures that the assistance provided is most relevant and efficient for each developer.

    Enhancing Accessibility of Coding for Non-Expert Users

    One of the most impactful features of code assistants is their role in democratizing coding. By simplifying complex coding concepts and automating mundane tasks, these tools will make software development more accessible to non-experts. Beginners and those learning new programming languages will find these assistants particularly useful, as they provide guidance and learning aids.

    Conclusion

    Code assistants powered by AI are becoming an integral part of the software development process. They not only make coding faster and more efficient but also reduce the chances of errors, making the resultant software more reliable. The role of code assistants is only expected to grow, bringing in more advanced and intuitive features. Whether you are a seasoned programmer or a newbie, embracing code assistants can be a game-changer for your coding journey.

  • Salesforce Adds Ability to Apply Custom Security Policies to APIs

    Salesforce Adds Ability to Apply Custom Security Policies to APIs

    Salesforce today added the ability to customize security policies for application programming interfaces (APIs) to the Mulesoft Anypoint API management platform.

    Gerry Egan, vice president of product management for Mulesoft at Salesforce, said this capability makes it possible for organizations to use an Anypoint Flex Gateway Policy Development Kit to streamline development of custom API security policies that can be implemented as code.

    In addition to providing integrations with integrated development environments (IDEs), the Anypoint Flex Gateway Policy Development Kit also provides test policies that can be employed to ensure API security.

    That approach makes it simpler to ensure APIs are secure as they are being built and deployed within the context of an automated DevOps workflow versus having to rely entirely on a separate API security platform, he noted.

    The Mulesoft Anypoint Gateway already comes with security policies that DevSecOps teams can readily implement. Salesforce is now adding the ability to apply custom policies that DevOps teams can apply as it becomes apparent cyberattacks against APIs are becoming more sophisticated, noted Egan. Those policies can, for example, be used to remove sensitive data or replace it with a token, he added.

    Responsibility for API security is often not well established in many organizations, but as more accountability for API security shifts left toward DevSecOps teams, there is growing interest in addressing the issue as code when APIs are developed and deployed. While cybersecurity teams are responsible for maintaining cybersecurity after APIs are deployed, few of them have any insight into how an API is crafted. That’s a significant issue because cybercriminals have become more adept at both exfiltrating data via external facing APIs in addition to manipulating the underlying business logic to compromise a digital process, noted Egan.

    The Mulesoft Anypoint Gateway automates the process of building and applying security policies to APIs as part of the software development life cycle (SDLC) in a way that minimizes any impact on developer productivity, he added. That approach provides the added benefit of reducing the level of cognitive load developers would otherwise experience if they had to manually create software policies, said Egan.

    In general, most APIs are internally facing, but it’s not uncommon for them to suddenly be exposed to the internet as application use cases evolve. The best way to ensure API security is at the point of creation. Providing developers with API security tools gives them an opportunity to address security issues at the beginning of the application development process.

    There have already been several cybersecurity breaches involving APIs in the past year. It may only be a matter of time before there are additional breaches that could prove catastrophic. Regardless of the size of the API breach, the application development team that created and deployed the API in the first place is ultimately going to be held accountable for fixing it. The challenge is to find the simplest way to eliminate the issue in the first place at a time when the number of APIs being built and deployed only continues to explode.

  • Graylog Makes Free API Security Tool Available to Developers

    Graylog Makes Free API Security Tool Available to Developers

    Graylog this week made available a free version of its platform for securing application programming interfaces (APIs), intended to encourage developers to adopt best practices to secure them.

    The free version of Graylog API Security has all the capabilities of the paid version but is limited to 16GB of local rolling storage on a single node with a one-year renewable license.

    Graylog CEO Andy Grolnick said the goal is to make it simple for developers to use this edition of the platform as they are building APIs. As applications are deployed in a production environment, the expectation is organizations will then need to access the version of the platform that is designed to scale, he added.

    Based on technology Graylog gained with the acquisition of an API security platform originally developed by Resurface.io, this free version of Graylog’s API security platform is trying to help bridge the divide between the application development teams that create APIs and the cybersecurity teams tasked with protecting them, said Grolnick.

    Capabilities of the platform include API classification, discovery, risk scoring, an ability to capture API request and response payloads and continuous monitoring of API and threat signatures in real-time. Collectively, these capabilities enable Graylog API Security to provide high-fidelity alerts using a data lake that is embedded in the platform, noted Grolnick.

    That approach enables Graylog API Security to capture all API requests and response details to distinguish valid API traffic from malicious activity involving, for example, data exfiltration hiding under valid response codes.

    In addition, Graylog API Security automatically surfaces remediation guidance for developers who typically lack cybersecurity expertise.

    API security has become a major DevSecOps issue because cybercriminals are increasingly targeting APIs to steal data. As more externally facing APIs are deployed, the overall size of the attack surface that needs to be defended increases exponentially.

    A recent survey conducted by Enterprise Strategy Group (ESG) on behalf of Graylog found more than three-quarters of respondents (76%) have an average of 26 APIs per application. Most respondents are using open APIs for public consumption (67%) or are connecting applications with partners (64%).

    In general, most of those APIs are internally facing, but it’s not uncommon for those APIs to suddenly be exposed to the internet as use cases for applications evolve. The challenge is that few cybersecurity teams have visibility into APIs that, when manipulated by malicious actors, can expose code or provide a mechanism through which business processes can be compromised. This issue often exists because, in many organizations, it’s still not clear who is actually responsible for API security.

    Arguably, the best way to ensure API security is at the point of creation. Providing developers with API security tools gives them a chance to do the right thing from the beginning of the application development process, said Grolnick.

    There have already been several cybersecurity breaches involving APIs in the past year. It may only be a matter of time before there are additional breaches that could prove catastrophic. Regardless of the size of the API breach, the application development team that created and deployed the API in the first place is ultimately going to be held accountable for fixing it.

  • Why Startups are Betting Big on Low-Code/No-Code

    Why Startups are Betting Big on Low-Code/No-Code

    It is exhaustive — from infrastructure to app delivery, from data to applications — to modernize your practices, processes and providers to ensure you have the underlying foundation to take advantage of whatever comes next.

    Two or three years ago, apps created through low-code/no-code platforms were not usually as detailed under the surface as software developed from scratch, yet they sufficed for certain purposes. There was even a clear distinction between software developers and everyone else out of necessity because software development was incredibly difficult to master.

    But now, as we head towards more advanced AI, the SaaS-based low-code/no-code (LCNC) platforms empower businesses to create software exponentially faster and cheaper than a code-based approach.

    The future, therefore, of startups in this changing business landscape becomes even more competitive, taking into account the increasing importance of customer-centric UI modeling, data product development and cutting-edge technologies like machine learning and deep learning.

    High-Value Acceleration

    Applications built through traditional software development can take months or even years to launch. If you create a code-based solution, it’s also easy to blame others and there’s a lack of understanding if it’s not well-documented. “Low-code no-code functionalities can change this dynamic,” says Dr. Ingo Mierswa, an industry-veteran computer scientist and founder of Altair RapidMiner. “The visual workflow describes what it’s doing, so people can understand it, buy into it and take ownership of the results.”

    Visual workflows can be understood and created by more people. “They make it easier to maintain and explain why anything, such as a model’s decision or a bug, has happened because the workflows are documenting themselves,” Mierswa articulates. “It would be hard to create such an explanation if you had to sift through 100,000 lines of code, especially if the code had been changed 17 times in the past two weeks.”

    You need to iterate, you will make mistakes, and you don’t want to waste time with coding non-critical things. “My big advice for all starters is to always think about what’s critical for your product. What’s your IP? What do you need to own and customize? And if coding is not that important for your product, I think going low-code/no-code is always the better way,” Mierswa shares. “It’s more important for startups because you have less resources, less time, more competitive pressure and markets are moving very quickly.”

    Everyone is a Citizen Developer

    In the early 1960s and 1970s, there was a clear distinction between software developers and everyone else out of necessity. Software development was incredibly difficult and time-consuming to learn and master. But now with the onset of low-code/no-code solutions, everyone from custodial teams to C-level executives can create and customize applications that make their jobs more efficient.

    Because no-code/low-code platforms are built on the fundamental premise. “People closer to the problem are better equipped to find simpler and effective solutions,” says Kissflow CEO Suresh Sambandam. “It’s a team sport, and accountability, the most important benefit of LCNC solutions, accelerates development and empowers even more people to collaborate the right way.”A big advantage,” Sambandam says, “is that CIOs of large enterprises can solve the IT talent shortage plaguing the industry today by leveraging expert business users who are ‘citizen developers.’ Many companies can’t avoid struggling to recruit and retain tech talent in a highly competitive market, but low-code/no-code solutions exceedingly help bridge that talent gap by freeing up the bandwidth of existing resources.”

    At the highest level, you always need people who understand the business problems that need to be solved. LCNC functionalities also empower adjacent team members — designers, product managers, data scientists and others — to take part in the different stages of development as the product takes shape.

    Reducing Technical Debt to Overcome Friction

    In an enterprise scenario, most of the core systems like ERP, CRM, SCM in the front end, as well as in the back end, are bought from standard vendors. There is NO differentiation, as all the top enterprises buy from the same vendor. On the other hand, the bulk of differentiation comes from middle-office processes that are unique to an enterprise. Sambandam points out, “Often these are business processes that require heavy domain knowledge that frequently change to adapt to the evolving business conditions and hence business users are better equipped to build these workflow automations.” He highlights that conventional software development models don’t do justice to the agility required by business users and are too complex for them to use. While business users have the domain knowledge, the system would also require integration touch points with other enterprise systems. These integrations often require deeper technical expertise.

    It is essential to create a cultural change within your organization, where it is not just about having the right tools, but also about investing in your employees and skilling them up, commented DevRev Head of Engineering Ahmed Bashir.
    It still is hard work, and there will be friction. “Overcoming friction requires creating a tighter loop across departments and managers, closing the gap between developers and customers,” he underscores. “And LCNC platforms are designed to act as a system of action, surfacing real-time information that connects work with developers, customers and product.”

    This is exactly where platforms like Kissflow, Blaze and Bubble, which support both no-code and low-code use cases come in and let business users handle the domain portion of the application (90%) and IT teams configure the integration points (10%). This greatly reduces friction between IT and business users, especially when it comes to solutions for long-tail internal workflows.

    Long-tail applications include things like approval management, creative requests, incident management, customer onboarding and IT helpdesk. “We looked at the space and decided to tackle this,” Sambandam shares.

    Long-tail apps and processes are often viewed by IT as a drain on time/resources they don’t have, yet it’s a lack of internal workflow processes automation that gum up digital transformation. “We found as we scaled the company that when you empower business users to quickly build and augment workflows that directly impact their day-to-day by giving them the tools to do so without advanced technical knowledge, they are motivated to make it happen,” he affirmed.

    Security is a Business Enabler

    The main objective of security is to protect organizations and people. Organizations prepare for potential security threats by implementing policies and ensuring they have the tools to mitigate and quickly respond to outside threats.

    However many low-code/no-code adopters do not have security expertise on their team so they rely on the LCNC platform to offer security features readily available for the apps they build. Because creating applications with custom code can lead to a variety of security issues. And such applications are difficult to secure, with the majority of tested applications containing one or more session management vulnerabilities, and others with input validation errors.

    Getting a firm handle on security means considering what to do. That sounds simple enough, but it’s surprising how many startups make blunders because of poor planning and shoddy strategies. “We’ve been looking at a trend. Companies want enterprise-level security like audit logs, SSO and other data security requirements for their apps,” commented Nanxi Liu, Co-CEO of Blaze. “Seeing this strong trend, we worked to design our platform with enterprise security and scalability in mind, since most early-stage companies do not have security expertise on their team and rely on platforms to offer advanced security features for the applications they build.”

    Make, however, no mistake — there is no best security but the best practices. “That’s part of why,” Liu says, “compliance-driven businesses like financial services and healthcare companies that require the highest level of security to build their customer portals, consider enterprise-grade no-code and low-code platforms that provide the required level of security.”

    With low-code/no-code platforms, your applications are secure with industry-standard protocols, data protection practices, and features to block unauthorized access.

    To underscore: LCNC allows non-technical people to build complex apps without needing to be familiar with traditional software logic. You don’t need computational thinking because visual components in low-code/no-code platforms automatically have the logic built-in. “And now with the mind-bending AI breakthroughs,” Liu remarks, “users can tell AI in natural language the workflow or feature they need and see it instantly created.”