devopsy.kinsta.cloud

Category: Enterprise DevOps

Dell Brings DevOps to Edge Computing Environments

Dell Technologies today updated its edge computing platform this week to make it simpler to programmatically provision infrastructure using DevOps best practices.

Phil Burt, senior director of project management for edge computing at Dell Technologies, said version 2.0 of Dell NativeEdge adds additional declarative blueprints based on YAML files and the Topology and Orchestration Specification for Cloud Applications (TOSCA) framework.

Blueprints for Telit, Litmus and PTC for manufacturing use cases, Deep North for retail, Dell Streaming Data Platform for analytics and Rancher Labs K3s for Kubernetes environments are provided.

Those blueprints make it simpler to either deploy applications on a lightweight operating system that Dell developed optimized for edge computing platforms or any other software stack an IT organization may prefer, he added.

Dell is also adding support for the virtual Trusted Platform Module (vTPM) and UEFI Secure Boot capabilities to apply zero-trust IT principles to edge computing platforms using hardware-based cryptography and secure storage for encryption keys, certificates and passwords.

Finally, Dell is also making available a three-year subscription plan for NativeEdge to lower the total cost of deploying edge computing platforms.

Dell relies on virtual machines it developed for edge computing platforms to deliver software. IT teams can then opt to deploy monolithic applications or container-based applications running on an instance of Kubernetes deployed as an extension of the virtual machine provided by Dell. Those platforms can then also automatically connect to a network to provide the connectivity required.

Regardless of approach, Dell is providing a method to programmatically orchestrate the management of highly distributed edge computing environments, noted Burt.

In the longer term, Dell is also researching how to apply generative artificial intelligence (AI) to the management of edge computing environments using the data its monitoring tools provide, he added.

While edge computing has been around in one form or another for decades, as more organizations start to process and analyze data at the point where it is created and consumed, the number of applications deployed at the network edge has increased substantially. As such, the number of applications that need to be built and deployed at the edge using DevOps best practices is growing exponentially. In fact, managing those workloads is only going to become that much more challenging as more AI models are deployed at the network edge.

Of course, not every workload at the edge is managed by an IT team. For years, many organizations have relied on operational technology (OT) teams that have historically deployed applications at the network using manual processes. Organizations that embrace DevOps practices to automate the deployment of workloads at the edge will naturally have to navigate some cultural issues alongside the technical challenges encountered when programmatically deploying software.

It’s not clear how much software will be running at the network edge in the years ahead, but as the capabilities of the IT infrastructure made available continue to increase, so will the complexity of the applications that will be deployed. The challenge, as always, is going to be finding the best way to manage all that distributed software at what will soon be an unprecedented level of scale.

February 23, 2024
DevOps: What’s the End Goal?

In high tech, we have a penchant for not actually having an end goal. We have interim goals but no grand “this is what we need to do.” And yet, every space inevitably has a “this is the reason” attached. So what should the overarching goal of DevOps be?

We started out with streamlining processes as the goal, and quickly morphed into efficiency and being more responsive–all worthy goals, but it is the nature of both technologists and business people (for very different reasons) to not stop when the goal is reached. We went through several more iterations that all basically pulled more under the DevOps umbrella, and then settled on automation. AI will continue this automation trend, but to what end?

Where, exactly, do we want to go? Theoretically, we could make AI write the code, build the code, test the code and deploy the code with only a small contingent of actual people involved in the process. Seriously, if the idea is to let business people crank things out a la the promises of 4GLs, then we are closer than we have ever been to achieving that goal.

But, much like calculators, someone will still have to create these systems, and we are faced with a different conundrum: If no one is writing new code, learning-based AI will struggle to solve new problems. That challenge can, in theory, be overcome by teaching AI to disassemble and abstract existing solutions, but that will take time.

The other thing that business people and technologists share in the modern world is a lack of actual philosophers. I am a technologist, but much of my immediate family enjoys philosophy. So, I dug into philosophy with regard to science many years ago, and philosophers, being esoteric, ruined their ability to influence scientific thought. Focusing on questions like, “What if tomorrow, we found aluminum that wasn’t really aluminum?” was dumb and undermined the core idea of “Science will tell us what we can do, philosophy will tell us what we should do.”

So we’re on our own in that regard, and given a worldwide development community, we can assume that just because you can, someone will. Our question then is, “What does a given enterprise want and need from their DevOps processes?” The rate of change is about to accelerate again, so knowing what is important to your organization will matter in the next five years. A company that uses technology in support roles has wildly different needs than one that uses technology to develop products, and they have very different needs than a company for whom technology is the product.

Is the goal to eliminate the bulk of IT? Or is it to streamline IT even further and make it even more responsive to business needs? Perhaps the goal is to develop entirely new products or markets with the time that AI has freed up. The difference is huge in terms of planning. And these are the types of questions coming. The idea that any given technology can make things (or make them happen) faster and more efficiently without changing staffing is naïve and ignores the history of the auto industry.

Get together, IT and business leaders. Develop a plan. Do you want to do more with less, or do you want to reduce overhead? Do you want to have IT specialize while AI does the mass of generic work? Level one help desk can be taken over by chatbots today. Is that the type of direction the organization wants to go? Tell IT management that change is coming; the question is, how the organization wants to leverage it and conscious decision is far better than accidental results.

devopsy.kinsta.cloud · No No-Shift, DevOps Jobs, AI Tests Your Code, DevOps End Goal

February 21, 2024
Embracing the Future: Navigating the Waves of AI in DevOps

In the rapidly evolving digital landscape, the advent of generative AI and large language models (LLMs) has ushered in a new era of innovation and transformation. As IT organizations pivot toward DevOps, DevSecOps and SRE mastery, leaders find themselves at the crossroads of excitement and anxiety. This dual sentiment stems from the vast potential of AI to revolutionize operations and the inherent challenges that accompany generative AI’s integration. In this article, we’ll explore the reasons behind this excitement and anxiety, outline the top use cases for generative AI and provide strategic guidance to ensure a smooth DevOps and digital transformation journey.

The Catalysts of Excitement

1. Enhanced Efficiency and Innovation: Generative AI, with its ability to automate complex processes and generate new ideas, promises unprecedented efficiency. It enables IT organizations to streamline development pipelines, reduce manual errors and foster innovation, making the leap toward DevOps and DevSecOps not just a goal but a tangible reality.
2. Improved Decision-Making: Large language models offer sophisticated data analysis capabilities, turning vast datasets into actionable insights. This empowers leaders to make informed decisions rapidly, optimizing operations and enhancing service reliability in line with SRE principles.
3. Competitive Advantage: In the digital age, staying ahead means adopting the latest technologies. Generative AI provides a unique competitive edge, allowing organizations to deliver superior digital experiences, innovate products and services and respond to market changes proactively.

Top Three Generative AI Use Cases in DevOps

1. Automated Code and Test Generation and Review: AI-driven tools can generate code and test snippets, conduct code reviews and testing and suggest optimizations, accelerating development cycles and improving code quality.
2. Security Enhancement: By integrating AI into security protocols, organizations can predict and mitigate potential threats more effectively, enhancing their DevSecOps initiatives with proactive rather than reactive measures.
3. Incident Management and Resolution: AI can automate incident response workflows, predict outages before they occur and suggest remediations, aligning with SRE goals of maintaining high availability and reliability.

Sources of Anxiety

1. Ethical and Privacy Concerns: The potential for misuse of AI technologies, including privacy violations and biased decision-making, raises significant ethical questions, creating apprehension among leaders.
2. Skill Gaps and Workforce Impact: The shift toward AI-centric operations necessitates new skills and roles. Leaders worry about the existing workforce’s ability to adapt and the challenge of filling emerging skill gaps.
3. Integration and Compatibility Issues: Integrating AI into legacy systems and ensuring compatibility across the digital infrastructure poses technical challenges, complicating the transition to advanced DevOps and SRE practices.

Navigating the Digital Transformation Journey

To harness the benefits of AI while mitigating its risks, leaders should consider the following strategic actions:

1. Foster an AI-Ready Culture: Cultivate a culture of continuous learning and adaptability. Encourage your team to embrace AI tools and methodologies, emphasizing the importance of upskilling and reskilling.
2. Implement Ethical AI Guidelines: Develop and adhere to ethical guidelines for AI use, focusing on transparency, accountability and fairness. Ensure privacy and security measures are integral to your AI initiatives.
3. Invest in Talent and Training: Address skill gaps by investing in training programs and partnerships with educational institutions. Consider hiring AI specialists to bridge the gap between traditional IT roles and AI requirements.
4. Prioritize Seamless Integration: Adopt a phased approach to AI integration, ensuring compatibility with existing systems. Leverage APIs and microservices architectures to facilitate smoother transitions.
5. Establish Governance and Oversight: Create a governance framework to oversee AI initiatives, ensuring alignment with organizational goals and compliance with regulatory requirements. This should include monitoring AI performance and its impact on operations and workforce dynamics.

Summary: Seize the AI Opportunity

As we stand on the brink of a transformative era, the fusion of AI with DevOps, DevSecOps and SRE practices represents a significant leap forward. While the journey is fraught with challenges, the potential rewards are immense. By embracing AI with strategic foresight, ethical consideration and a commitment to continuous improvement, IT leaders can propel their organizations toward unparalleled efficiency, innovation and competitive advantage.

In conclusion, the integration of AI into DevOps to further accelerate digital transformation is not just an option but a necessity for staying relevant in the digital age. The journey requires careful navigation, but with the right approach, IT organizations can emerge stronger, more agile and better equipped to face the future. Let’s embrace this opportunity to redefine the digital landscape, ensuring our transformations are not just successful but sustainable and responsible.

Embrace the future; embrace AI.

February 20, 2024
What the Evolution of Specialized Hardware for AI and ML Means for DevOps
The widespread adoption of artificial intelligence (AI) and machine learning (ML) technologies is accelerating the evolution of computational hardware, essential for automating complex processes and enhancing accuracy in decision-making. This acceleration is crucial in advancing computer science and data processing, especially within the various segments of AI/ML data pipelines.

This growing demand is prompting a diverse array of chip manufacturers, from established players to emerging contenders, to innovate and lead in the development of faster and more efficient processing solutions. The primary goal? To design chips that optimize data transfer, improve memory management and enhance power efficiency. These advancements are far from incremental; they are pivotal in meeting the escalating demands of sophisticated AI and ML applications.

This evolving hardware landscape for DevOps necessitates greater unification and automation of the various applications to the specialized AI infrastructure. With chip architectures diversifying, building the application stacks focusing on portability, performance and ease of access becomes even more crucial. The ability to seamlessly embrace multiple architectures will be key to striking the right balance for the varying technical abilities of the people who want to interact with technology.

This article explores the implications of these hardware advancements on DevOps processes within AI and ML. Additionally, we explore strategies DevOps teams may consider to ensure applications remain efficient and portable across various chip architectures.

The Rise of Specialized Hardware

Historically, general-purpose hardware, including GPUs and CPUs, was the staple for many workloads. However, a clear pivot to specialized hardware is underway in artificial intelligence and machine learning, where training and inferencing demands have grown exponentially. These applications often hit performance limitations inherent in traditional hardware, partly due to the modern constraints of Moore’s Law. As a result, there is an increasing need for hardware capable of handling specific AI tasks with increased efficiency and speed. For instance, in certain machine learning scenarios, using hardware that supports single-precision floating-point computations can speed up processes without the need for the accuracy provided by double-precision computations.

Although NVIDIA remains a dominant force in the AI chip market, the competition is heating up, with various companies offering innovative alternatives. And it’s not only from the usual suspects like Intel or AMD; Google has made strides with its Tensor Processing Units (TPUs). Amazon recently announced Trainium2, a new AI chip designed specifically for training AI systems. This chip, set to compete with Microsoft’s Maia and Google’s TPUs, underscores the growing custom AI chip development trend among major tech companies. Beyond these giants, startups such as Cerebras, SambaNova Systems, Graphcore and Tenstorrent bring fresh takes on AI hardware solutions.

Challenges for DevOps

As specialized hardware becomes more prevalent, the DevOps community will need to manage various new challenges, including performance portability. Performance portability refers to ensuring that applications run efficiently and perform well across varying computing architectures with minimal to no modifications.

Cognitive computing (the broader category of AI and ML) varies in complexity, depending on the algorithms, models and creators’ unique demands for hardware-specific features. While an architecture-tailored version will certainly maximize performance on respective platforms, it complicates the process of ensuring a consistent software experience across diverse hardware.

The challenge of system design lies in optimizing the environment for maximum efficiency, especially when the precise nature of the workload is unknown to those responsible for designing and supporting the systems.

Of course, there are also significant and related considerations with continuous integration and continuous deployment (CI/CD) pipelines. The intricacies of CI/CD pipelines are magnified when pursuing performance portability. The need to validate software performance across multiple hardware configurations introduces a more elaborate testing matrix and can extend deployment cycles, directly affecting time-to-market requirements. Suddenly, workloads are now crossing the traditional IT infrastructure and high performance/supercomputing boundaries once defined by microservice and batch processing technologies; they are now one in a CI/CD pipeline.

As organizations adopt specialized hardware, there’s the potential for a parallel rise in specialists focusing solely on one type of hardware or application use case. While such expertise can drive innovation and optimization for a particular platform, it also creates complexity and the potential for knowledge silos and unnecessary complexities for the operations teams and clients that use those systems.

Leveling up Performance Portability

Performance portability and closely related concepts, such as hardware-agnostic performance and cross-platform efficiency, are increasingly important for DevOps teams. As the technological landscape shifts, the pressing question becomes: How can the industry and DevOps teams navigate this evolution seamlessly?

Ongoing research and development will no doubt play a key role. For example, the U.S. Department of Energy (DoE) is exploring new methodologies to support its Exascale Computing Project. This includes refining existing software libraries, pioneering new programming models and developing new tools that could eventually influence wider DevOps practices. Other researchers are developing software abstraction layers, aiming to simplify the adaptation of generic code for specific hardware configurations.

Beyond new tools and methodologies that may come from current R&D efforts, there are many existing tools and processes that lend themselves to improving performance portability, including:
- Containerization: Containers encapsulate applications and their dependencies in a way that helps ensure they run consistently across various environments. Open source tools like SingularityCE with Open Container Initiative (OCI) compatibility can help standardize and simplify deployment across different hardware configurations, promoting performance portability for high-performance computing and traditional IT infrastructure management.
- Benchmarking and profiling: To achieve performance portability, it’s imperative to understand how software behaves across different architectures. Benchmarking tools provide quantitative performance measures, while profiling tools offer insights into software behavior, helping developers identify bottlenecks and areas that need optimization.
- Code Portability Libraries: In addition to libraries like OpenCL that enable software execution across diverse hardware, recent advancements in container technologies complement this capability. For example, enhancements in container device interfaces, such as those in SingularityCE, streamline the integration of hardware-specific resources. This development aids DevOps teams in optimizing software for various hardware without extensive codebase rewrites, exemplifying the tools supporting hardware diversity and software agility in all aspects of cognitive computing.
Of course, on top of all these tools and strategies, agile methodologies will remain essential since they prioritize iterative development, continuous feedback/improvement, and adaptability—all of which are important to fast-evolving hardware and software configurations.

Looking Ahead: Adaptability as the Key

As we embrace the new frontiers in AI and ML, the role of DevOps teams in navigating a constantly evolving hardware landscape becomes increasingly vital. At the heart of this journey lies the formidable challenge of application portability—a challenge that calls for technical expertise and a strategic shift toward adaptability. Enter containers emerging as indispensable tools that ensure a consistent application experience and performance across diverse platforms and handle the intricacies of portability.

Likewise, adopting agile methodologies transcends process adherence; it embodies a mindset of flexibility and responsiveness, essential in rapid technological shifts. These approaches, far from temporary fixes, are integral to a strategy that aims to unleash the potential of AI. As DevOps teams continue to navigate these challenges, their success will depend on their adaptability and willingness to explore and integrate established and emerging technologies—particularly those excelling in scalability and efficiency. This proactive exploration and integration will be the key to surviving and thriving in this dynamic technological landscape. And yet, while we have discussed this problem regarding scientific applications, the impact is also felt on the AIOps side of the house, using AI-specific hardware with AIOps practices. While our goal here was to discuss the complexities of creating and administering systems for artificial intelligence and machine learning, we have yet to approach the security conversation, particularly with confidential computing, which is a topic for another time. Happy computing.
February 16, 2024
IT Professionals Have Mixed Emotions About AI

A survey of 1,213 IT decision-makers working for small-to-medium enterprises (SMEs) in the U.S., United Kingdom and India published today found nearly half (45%) are worried about the impact artificial intelligence (AI) will have on their job.

Conducted by the research firm Propeller Insights on behalf of JumpCloud, a provider of an IT and cybersecurity management platform, the survey also found more than three quarters (76%) agree their organizations should be investing in AI, with 79% viewing AI as a net positive for their organization.

Most respondents also agree their organizations are approaching AI at exactly the right speed (55%), compared to 22% who said their organization is moving too quickly and 19% who said their organization is moving too slowly.

However, a full 62% also noted that AI is outpacing their organization’s ability to protect against threats, the survey finds.

Tom Bridge, a principal product manager for JumpCloud, said while there is no doubt that AI will change roles within organizations, it’s not likely to replace the need for IT administrators. Instead, IT administrators will be able to manage complex IT environments at much higher levels of scale as AI becomes a force multiplier for managing IT. Many of the low-level tasks that conspire to make managing IT tedious, such as generating reports, will become increasingly automated, noted Bridge.

It’s not clear what impact AI will have on IT roles, but it is arriving at a time when IT organizations are being challenged on several fronts. For example, the survey finds that 56% of respondents are more concerned about their organization’s security posture than they were a year ago. Nearly three-quarters (72%) said any cuts to their security budget would increase organizational risk.

More than half (56%) identified security as their biggest IT challenge, followed by new services and application rollouts (45%), increased work burden (44%) and the cost of remote work solutions (42%). Respondents said network attacks were their biggest challenge (40%), followed by software vulnerability exploits (34%) and ransomware (29%). A full 83% also now require multi-factor authentication (MFA), while two-thirds require biometrics (66%) to access some portion of their IT resources. A total of 83% are also still managing passwords.

More than three quarters (76%) also report increased compliance and regulations requirements in their region.

In addition, a full 88% noted increased vendor prices over the last six months, the survey finds. More than a third of respondents need five to 10 applications to manage worker life cycle (37%), but 22% require 11 or more. Three-quarters (75%) said they would prefer a single tool to do their job over several point solutions.

More than three-quarters (76%) rely on a managed service provider (MSP) to manage some portion of their IT environment, with 42% now relying on an MSP to manage their IT environment completely.

Finally, 57% said their organization has experienced layoffs in the last year. In addition to having to offboard those employees, IT professionals will naturally become more uneasy about their own job security.

Arguably, when it comes to managing IT, there is less certainty today than at any time in recent memory. The challenge, as always, is to aggressively embrace automation as much as possible to reduce a level of IT complexity that is rapidly becoming too complex to manage otherwise.

February 14, 2024
Data Gravity Will Remain an Issue

Things are improving for IT at a rate we haven’t seen since the first wave of container adoption. We have massive automation in the entire SDLC—with AI-based plug-ins for IDEs to help developers write code that is both higher quality and more secure, security deeply integrated into the DevOps toolchain and the unification of testing/security tools across the SDLC. We are once again turning out more code of higher quality faster than we were just a year ago.

And what is finally starting to catch up is data. I love the current iteration of data virtualization technology, where it can be set to move from region to region or cloud to cloud at leisure in the background. At the same time, data that is accessed in the interim can be instantly transferred. I used to cover storage and data, and frankly, this is the dream world.

But it doesn’t change the fact that data location matters. While bulk moving data to its final destination will be useful, separating data from applications that access it is simply adding another weak link in the application infrastructure chain.

This is where the true strength of containers and Kubernetes come in. With Kubernetes, we can put containers with the entirety of our apps into the environment where our data resides. And that means that our application infrastructure is consolidated and that, in a pinch, both application and data can be moved anywhere–because Kubernetes is truly portable (as long as you don’t use customization features of some vendors/platforms anyway).

The environments we currently choose to use for enterprise applications–from mainframe to public cloud and everything in between–all are capable of running containers, and while there are still deployment differences, customizing a bit to move an entire application is far better than rewriting entire apps to target a new host environment. And the amount of retargeting required is constantly going down.

So, decide where you would like to host your solution, use data virtualization to move the datasets there, spin up your apps in Kubernetes at that location and enjoy the fruits of your labors. Mergers, acquisitions, moves from one architecture to another, moving from public cloud vendor A to public cloud vendor B … All made far easier by data and Kubernetes portability.

While people like to call it “cloud,” what we really should be calling it is “portable.” Whichever marketing person decided that cloud included Kubernetes is my sworn enemy, btw. Because the cloud is used without including Kubernetes, so of course, that just confuses the issue. Portable programming is a far better description of data mobility and Kubernetes architecture used in tandem. Doesn’t need a cloud at all.

And we’re headed there for even more productivity. Just pick where to move it and carry on. We do indeed live in pretty cool times, and you all are the ones making it real. Keep up the good work.

Image source: https://vecteezy_businessman-holding-social-planet-showing-networking-skills_1268342.jpg

February 14, 2024
How GitHub Approaches Internal Developer Experience

Developer experience (DX) has been the talk of the town, and for many reasons. Quality DX is intrinsically tied to increased productivity, velocity and developer happiness. Organizations that invest in DX tend to see efficiency improvements and less employee churn, contributing to reduced costs.

As such, much effort is being placed on ways to improve the experience developers have with their internal workflows and tools. But what are some good models of developer experience in practice? For that, let’s turn to GitHub.

GitHub, the ubiquitous code repository and version control platform, is naturally a developer-favorite tool. And internally, GitHub is constantly seeking to improve the experience its own developers have in building, deploying and maintaining software. Below, we’ll explore how GitHub approaches DX and instills these traits into its software development culture.

Allocating Time For Deep Work

The most crucial practice GitHub takes is allowing developers to enter the flow state and stay there. Dr. Eirini Kalliamvakou, staff researcher at GitHub, defines “deep work” as time blocked off intended for focus. “During that time, you experience as little interruption as possible,” she said. According to Kalliamvakou, employees at GitHub actively block off time for deep work — some teams even have “no-meeting Thursdays.”

There is research to support the benefits of allocating time for deep work. As I previously covered, one internal study of Microsoft employees found that developers who formally set aside focus time for coding experienced a significant boost in overall satisfaction and perceived productivity.

More recently, GitHub partnered with research group DX for a study, DevEx In Action, that assesses the observable outcomes of improving developer experience. Impressively, the results found that developers who dedicate significant time to deep work enjoy a 50% productivity boost.

Using AI Pair Programmers

It will come as no surprise that developers at GitHub dogfood GitHub Copilot, the AI-powered code completion tool built on OpenAI’s Codex. According to Jon Peck, senior manager, developer relations & enterprise advocacy at GitHub, Copilot is truly integrated into most of his daily tasks. “Copilot lives with me in any development environment I’m using,” he said.

Nowadays, the technology can enable complete, viable functions that are contextually and stylistically aware, he said. Furthermore, Copilot Chat now integrates into Jetbrains and VSCode, bringing it closer to the programmer’s accustomed development environment. Peck specifically highlights developer experience gains from using it for boring activities, such as building unit tests for new code or auto-summarizing the functionality of components.

Running Automation in the Background

Having more automation baked in is another way GitHub enhances its developer productivity and experience. “Developer-facing automation allows devs to stay in the flow longer, interrupting them only when something needs their attention,” said Peck.

For example, teams utilize GitHub Actions for all kinds of triggers, such as responses to new code commits or changing the state of issues, said Peck. Running asynchronous tests in the background and notifying the developer only if something breaks enables them to stay head-down in the code for more extended periods. Additionally, asynchronous communication around pull requests and code reviews can ensure teammates collaborate effectively on their own time.

These traits are often adopted in cloud-native software development cultures like GitHub. The more you can make tests and build processes run in the background, the better, explained Kalliamvakou. Plus, reducing notification fatigue is another way to ensure developers aren’t interrupted unless something really needs their attention.

Regularly Collecting Feedback

To optimize developer experience, it’s a good idea to collect developer feedback. For instance, at GitHub, their developer experience team regularly conducts internal surveys to surface areas for improvement — this helps gauge satisfaction with the amount of deep work developers are engaged in. Similarly, LinkedIn regularly collects qualitative input using an internal framework to gauge developers’ satisfaction with their tools.

GitHub also runs a newsletter to spread awareness about what new internal features they’re introducing and to regularly review the state of things. “When you introduce a developer experience initiative, you need to create awareness around it and track how people are responding over time,” said Kalliamvakou. Keeping an active tab on the success of these initiatives is a good health check to avoid burnout.

Shifting Security Left A Bit

Another area where GitHub focuses on improving developer experience is around security. Traditionally, systems perform security scanning after all code is committed. However, this can be a big pain to go back and fix, especially when you need to track down multiple dependencies and don’t have great visibility.

“The closer you get security scanning to the point where the vulnerability was created, the easier it will be to remediate it,” said Peck. Shifting left to detect potential vulnerabilities in the moment and offering “one-click to remediate” options can significantly enhance the developer experience. He also described how GitHub engineers dogfood GitHub’s advanced security features to perform things like ongoing secrets scanning, input sanitization and pattern-based analysis.

Making Processes Understandable and Intuitive

Interestingly, the DevEx in Action study found that developers who report a high degree of understanding of their code feel 42% more productive than those with low or no understanding. So then, how can we enhance our understanding of code?

Often, a developer might forget the context behind something they wrote last year, or something a teammate programmed might seem obfuscated. This is another area where AI could be utilized to generate documentation automatically. However, the future of code understandability goes beyond just static documentation.

“The trend is toward learnability right where they are, to keep them in the flow,” said Kalliamvakou. She indicates that AI-driven insights embedded into the IDE that explain what a program or function means make the developer workflow highly intuitive.

Offering Cloud-Based IDEs

Developers often run into the “works on my machine” problem, which can be a big developer experience hurdle. In essence, applications depend on far more than just the code — they are at the whim of the environment, local dependencies, its configurations, and the actual device running the program.

By using cloud-based IDE like Codespaces, said Peck, GitHub developers are able to spin up a container in the cloud and retain the same configurations. The benefit of this is that you can keep your local editing experience as well, he said.

Retaining An Engaged Developer Experience

According to Kalliamvakou, the benefits of developer experience are no longer just anecdotal — we now have real-world evidence to back up these claims. For instance, developers who find their work engaging feel 30% more productive, according to the aforementioned report.

It seems that having an AI coding assistant by your side trained on a large language model (LLM) can encourage developer satisfaction and productivity gains. Introducing AI-based tooling can help automate away some of the unfulfilling work, leaving more time for more engaging activities, said Kalliamvakou.

But although AI can solve many things, there will always be some degree of toil. Kalliamvakou recommends distributing grunt work across multiple employees and avoiding throwing it all on one person! At GitHub, the DevEx team also analyzes the efficiency of meetings to remove non-high-quality meetings, which can also benefit engagement.

February 8, 2024
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.

February 7, 2024
DevOps Guide to Java Profiling
Java profiling is a technique used to understand the detailed behavior of a Java application. It involves monitoring and measuring various aspects of a program’s execution, such as memory usage, CPU utilization, thread execution and garbage collection.

Java profiling can be used in various stages of the software development life cycle (SDLC). During development, it can help identify bottlenecks and performance hotspots, which can then be optimized for better performance. In the testing phase, profiling can be used to verify that the application performs as expected under load. Finally, in production, profiling can be used to monitor application performance and detect potential problems before they affect users.

Java profiling tools provide insights into the Java Virtual Machine (JVM) and the application running on it. They allow developers to monitor thread execution, object creation, garbage collection and many other aspects of JVM operation. By using a Java profiler, developers can gain a deep understanding of the application’s performance characteristics and identify potential areas for optimization.

Why is Performance Tuning Important for DevOps?

Impact on Application Efficiency and Scalability

Performance tuning plays a vital role in DevOps by enhancing the efficiency and scalability of applications. Efficient applications use fewer resources, which reduces costs and allows for more users or larger workloads. Scalability is the ability of an application to handle increased workloads without a decrease in performance. By identifying and eliminating performance bottlenecks, DevOps teams can ensure that applications scale effectively as demand increases.

Relationship Between Performance and User Experience

Performance is directly related to user experience. A slow or unresponsive application can frustrate users and lead them to abandon the application altogether. By ensuring that applications perform well, DevOps teams can improve user satisfaction and retention. Furthermore, by monitoring application performance in production, DevOps teams can proactively identify and resolve issues before they impact users.

Cost Management and Resource Optimization

Performance tuning can also help with cost management and resource optimization. By optimizing application performance, DevOps teams can reduce the amount of computing resources required to run the application. This can result in significant cost savings, especially in cloud environments where costs are directly tied to resource usage.

Moreover, by understanding the application’s resource usage patterns, DevOps teams can make more informed decisions about resource allocation and capacity planning. This can help avoid over-provisioning, which leads to wasted resources, or under-provisioning, which can result in poor application performance.

Common Java Performance Issues

Memory Leaks

Memory leaks are a common performance issue in Java applications. A memory leak occurs when an application continuously allocates memory but fails to release it when it is no longer needed. Over time, this can lead to OutOfMemoryError exceptions and can cause the application to crash.

Java profiling can help identify memory leaks by monitoring the application’s memory usage over time. If the memory usage continuously increases even when the application is idle, this could indicate a memory leak. Profiling tools can also provide insights into the objects that are consuming the most memory, which can help locate the source of the leak.

Thread Contention and Synchronization Issues

Thread contention and synchronization issues can significantly impact the performance of Java applications. Thread contention occurs when multiple threads attempt to access a shared resource simultaneously, causing them to wait and leading to reduced performance. Synchronization issues, such as deadlock and livelock, can cause threads to become stuck, preventing them from making progress.

Java profiling can help detect thread contention and synchronization issues by monitoring the state and execution of threads. Profiling tools can show which threads are running, waiting or blocked and can provide a stack trace of each thread, which can help identify the cause of contention or synchronization issues.

Garbage Collection Overhead

Garbage collection is a key aspect of Java’s memory management, but it can also be a significant source of performance overhead. During garbage collection, the JVM pauses application execution to reclaim memory from objects that are no longer in use. If garbage collection occurs too frequently or takes too long, it can lead to application pauses and reduced performance.

Java profiling can help understand and optimize garbage collection behavior. Profiling tools can provide detailed information about garbage collection events, such as their frequency, duration and the amount of memory reclaimed. This information can help developers tune the garbage collector’s configuration to minimize its impact on application performance.

Resource Starvation

Resource starvation is another common performance issue in Java applications. It occurs when a system or process is unable to gain sufficient access to resources, leading to reduced performance or failure. In Java applications, resource starvation can be caused by factors such as insufficient memory, CPU, disk space or network bandwidth.

Java profiling can help detect and resolve resource starvation issues. By monitoring resource usage, profiling tools can identify when resources are becoming scarce and provide insights into the factors contributing to resource starvation. This information can help developers optimize resource usage and ensure the application has sufficient resources to perform effectively.

Key Features of Java Profiling Tools

Java profiling tools typically provide the following features:
- Ability to detect memory leaks: Memory leaks can be a significant issue in Java applications as they can lead to an out-of-memory error, disrupting the smooth running of the application. Profiling tools can help identify these leaks, allowing developers to fix them before they cause bigger issues.
- CPU profiling: This allows developers to see how much CPU time each method in their application is consuming. By identifying methods that are consuming a disproportionately high amount of CPU time, developers can optimize their code to improve its performance.
- Detailed thread profiling: This can help developers to identify synchronization issues, deadlocks, and other potential problems in multi-threaded applications. By providing this critical insight, profiling tools can help developers to create more efficient, high-performing applications.
Best Practices for Java Profiling

Here are some best practices to make the most out of your Java profiling efforts.

Identifying Key Performance Metrics

First and foremost, it’s essential to identify the key performance metrics that are most relevant to your application. The metrics you choose will depend on the nature of your application and its performance requirements. Some common metrics include response time, CPU usage, memory usage and garbage collection activity. By identifying these key metrics, you can use your profiling tools to monitor them and identify any potential issues.

Integrating Profiling in CI/CD Pipelines

Another best practice is to integrate profiling into your Continuous Integration/Continuous Deployment (CI/CD) pipelines. This allows you to catch performance issues early in the development process, before they become more difficult to fix. By regularly profiling your application during development, you can ensure that any changes you make don’t adversely affect its performance.

Profiling in Real-World Scenarios

While it can be useful to profile your application under controlled conditions, it’s also important to do so in real-world scenarios. This means profiling your application when it’s under load, when it’s dealing with real data, and when it’s running on the same hardware and software configurations as it will in production. By doing so, you’ll get a much more accurate picture of how your application performs in the real world.

Collaboration and Knowledge Sharing

Finally, Java profiling should not be a solitary activity. It’s important to share your findings and insights with your team, and to collaborate on solutions to any performance issues you identify. By doing so, you can build a culture of performance awareness within your team, and ensure that everyone is working towards the common goal of creating efficient, high-performing Java applications.

Java profiling is a vital part of the software development process. By understanding its key features and following best practices, you can use it to create applications that are efficient, high-performing and able to meet the demands of the modern world. So don’t underestimate the power of profiling—embrace it, and watch your Java applications reach new heights of performance.
February 7, 2024
We Will Control the World!

One thing about centralizing control is that there always has to be someone in charge. That can be a very good thing or a very bad thing. In IT, it doesn’t even get far enough to be a terrible thing.

Generative AI and increasing integrations have renewed the insistence from the crowd that it is certain they should control every little thing in your (virtual) data center. The idea that a given vendor should be the configuration and management point for a wide variety of tools – their own, competitors and nearby market tools – has been around forever. Vendors love the idea that they have that level of input into your infrastructure and, let’s be honest, many of us love the idea of having it taken care of for us.

But there are several questions to ask here. First, what is the likelihood that vendor X will have a great level of support for the tools from other vendors in your infrastructure? I mean, before we even get into the idea that this desire for control is not at all altruistic (we’re not talking Stalin here, but we certainly aren’t talking Washington, either), there is the question of how AI will be able to learn about and configure/manage a competitor’s products. Watching wire traffic? Well, if the competitor’s systems are super-well-known and the format of configuration APIs/files are well known—maybe? But this leads us to the real problem.

My advice to vendors would be to get their own products under control first. We work in a high-complexity field where the tools require a lot of specific domain knowledge to manage, and even more to manage well. Vendors have generally taken for granted that this level of knowledge would be available. Before making that level of knowledge unnecessary for competitors or spiderwebbing into competitor installs, make your tool(s) damn simple to use. That doesn’t mean you have to simplify it—you have the power of AI and are going to focus on configuration and management. So nearly eliminate configuration issues with your own products.

Example: “Great Security Tool, I just added an API at https://devopsy.kinsta.cloud/rocks. Please lock it down so it is accessible only to users in the WeRule group, then generate a WAF rule to keep it from being used to access more than three records a day, and only allow GET and POST calls.” Most vendors across the industry aren’t even close to this level of simplicity, so why in the world would you trust them to configure/control other vendor’s products?

There is a trend to make products cover more of the space they are in. This is very big in security right now, but you also see it in DevOps. CI/CD/CDD/VC/kitchen sink (KS)—I’m okay with that, as it does offer us simplified configuration and better cross-app communication. I think this is a better route than trying to serve as command-and-control for an entire tech stack that the vendor does not own. I still want point products and best-of-breed available, but a lot of us just don’t have the time and resources to implement five different products to get the job done—even if they’re “free,” as we all know, they are not free—so one vendor doing an entire chain is great for that use case, and often the shared information about the app, security, the network, etc. can work together better than the sum of its parts. So let’s stay in the “umbrella app” lane and not get carried away with trying to drive in the “manager of the entire world” lane.

We’re busy, we’re tired and many of us are jaded. So don’t tell us how you can manage other vendors’ tools, tell us how you’re making it easier to manage yours. Thanks, from all of us in IT.

February 7, 2024