24Metrics

24metrics

184 Stories To Learn About Rest Api

174 AI Tools To Try

No, You Don't Need a Highly Specialized Team to Build Your SaaS Application 

Java Backend Observability with OpenTelemetry Traces and Minimal Code

ওপেনটেলিমেট্রি ট্রেস এবং ন্যূনতম কোড সহ জাভা ব্যাকএন্ড পর্যবেক্ষণযোগ্যতা

Java-Backend-Beobachtbarkeit mit OpenTelemetry Traces und minimalem Code

Observabilidad del backend de Java con trazas de OpenTelemetry y código mínimo

Observabilité du backend Java avec les traces OpenTelemetry et le code minimal

ओपनटेलीमेट्री ट्रेसेस और न्यूनतम कोड के साथ जावा बैकएंड अवलोकनीयता

OpenTelemetry トレースと最小限のコードによる Java バックエンドの可観測性

OpenTelemetry 추적 및 최소 코드를 사용한 Java 백엔드 관찰성

Observabilidade do backend Java com OpenTelemetry Traces e código mínimo

Наблюдаемость Java Backend с помощью трассировок OpenTelemetry и минимального кода

OpenTelemetri İzleri ve Minimal Kod ile Java Arka Uç Gözlemlenebilirliği

Khả năng quan sát Java Backend với OpenTelemetry Traces và mã tối thiểu

使用 OpenTelemetry Traces 和最少代码实现 Java 后端可观察性

Many crypto users think the space is completely run by smart contracts powered by hamsters on a wheel in some warehouse. Others think it’s all mysteriously run by a shadowy organization bent on world domination. The reality is that behind that curtain are market makers. While they have nothing to do with a protocol’s contracts, they do their part to keep markets liquid and prices stable. The decentralized universe of Web3 presents opportunities and challenges for market makers. Kairon Labs, a major player in the space, agreed to contribute to this article to demystify some things and separate fact from fiction. Technical Metrics for Evaluating Web3 Asset Liquidity Market makers focus on specific metrics to gauge liquidity: Trading Volume: Indicates market activity and potential liquidity.
Order Book Depth: Helps understand the availability of buy and sell orders at different prices.
Bid-Ask Spread: Measures the difference between buying and selling prices.
Price Volatility: Reflects the extent of price fluctuations.
Slippage: Represents the difference between expected and actual trade prices. These metrics are essential for assessing trade execution ease and ensuring sufficient liquidity. Decentralization's Impact on Market Making Web3's decentralized nature reshapes the environment in which market makers live. They now operate across both centralized and decentralized exchanges. While traditional roles focus on liquidity and price stability, Web3 introduces automated market-making and on-chain liquidity pools. Navigating these environments requires innovative strategies. “While the core role of market makers remains centered on providing liquidity and reducing price volatility, the decentralized nature of Web3 introduces additional layers of complexity. The decentralized aspects of Web3, such as automated market-making and on-chain liquidity pools, require market makers to integrate new strategies and tools. Still, these remain supplementary to the primary focus on centralized exchanges,” said Kairon Labs CEO Mathias Beke. Pivoting on the Fly Blockchain technology advancements profoundly impact market makers' decision-making. For instance, breakthroughs in decentralized finance protocols, gaming, and NFTs can signal potential market volume increases. Market makers leverage these advancements to enhance trading strategies. Challenges of Operating in These Ecosystems Market makers face challenges in the fast-paced Web3 environment. Keeping up with evolving technologies demands constant vigilance. Deciding which innovations to integrate requires careful consideration. Protocol risks, such as vulnerabilities in smart contracts, can jeopardize funds. Balancing innovation with security is crucial. The rep from Kairon Labs stated, “There is always a protocol risk, where badly developed technologies could result in loss of funds. It could be hacks, exploits, or some kind of bad code.” These teams must fully understand the smart contracts they interact with to mitigate those risks. Developing proprietary smart contracts can optimize on-chain operations, liquidity provision, and trading strategies. “UniswapV4's custom Hooks exemplify the increasing importance of smart contract expertise. Any time these teams upgrade to a newer, and hopefully better, version, there’s more risk and more complexity,” added Beke. On Using Data Analytics Tools and Automated Trading Systems Tracking token movements and on-chain analytics provides valuable insights. Tools like Etherscan and Chainalysis help predict market trends and avoid skewed inventories. These insights enhance decision-making and strategy formulation. Automated trading systems are a must-have for any market maker. They enable rapid trade execution, real-time market reaction, and liquidity maintenance across multiple venues. Beke added, “All of these systems and tools are crucial in the Web3 space. They help market makers manage complex trading strategies and reduce manual intervention.” Market Making Is the Epitome of Technical Trading Market makers are the backbone of liquidity and price stability in the rapidly evolving Web3 landscape. Their reliance on technical analysis and a range of key metrics is essential for navigating the complexities introduced by decentralized environments. As they pivot between traditional and innovative strategies, these teams must remain vigilant in adapting to new technologies while balancing security and protocol risks. Advanced data analytics tools and automated trading systems streamline their operations and enhance their ability to respond swiftly to market movements. Ultimately, the successful adaptation to these challenges will determine the continued relevance and effectiveness of market makers in the dynamic crypto realm. Thanks to the Kairon Labs team for their participation. Many crypto users think the space is completely run by smart contracts powered by hamsters on a wheel in some warehouse. Others think it’s all mysteriously run by a shadowy organization bent on world domination. Many crypto users think the space is completely run by smart contracts powered by hamsters on a wheel in some warehouse. Others think it’s all mysteriously run by a shadowy organization bent on world domination. The reality is that behind that curtain are market makers. While they have nothing to do with a protocol’s contracts, they do their part to keep markets liquid and prices stable. The decentralized universe of Web3 presents opportunities and challenges for market makers. Kairon Labs, a major player in the space, agreed to contribute to this article to demystify some things and separate fact from fiction. Technical Metrics for Evaluating Web3 Asset Liquidity Market makers focus on specific metrics to gauge liquidity: Trading Volume: Indicates market activity and potential liquidity. Order Book Depth: Helps understand the availability of buy and sell orders at different prices. Bid-Ask Spread: Measures the difference between buying and selling prices. Price Volatility: Reflects the extent of price fluctuations. Slippage: Represents the difference between expected and actual trade prices. Trading Volume: Indicates market activity and potential liquidity. Order Book Depth: Helps understand the availability of buy and sell orders at different prices. Bid-Ask Spread: Measures the difference between buying and selling prices. Price Volatility: Reflects the extent of price fluctuations. Slippage: Represents the difference between expected and actual trade prices. These metrics are essential for assessing trade execution ease and ensuring sufficient liquidity. Decentralization's Impact on Market Making Web3's decentralized nature reshapes the environment in which market makers live. They now operate across both centralized and decentralized exchanges . While traditional roles focus on liquidity and price stability, Web3 introduces automated market-making and on-chain liquidity pools. Navigating these environments requires innovative strategies. decentralized exchanges decentralized exchanges “While the core role of market makers remains centered on providing liquidity and reducing price volatility, the decentralized nature of Web3 introduces additional layers of complexity. The decentralized aspects of Web3, such as automated market-making and on-chain liquidity pools, require market makers to integrate new strategies and tools. Still, these remain supplementary to the primary focus on centralized exchanges,” said Kairon Labs CEO Mathias Beke. Pivoting on the Fly Blockchain technology advancements profoundly impact market makers' decision-making. For instance, breakthroughs in decentralized finance protocols, gaming, and NFTs can signal potential market volume increases. Market makers leverage these advancements to enhance trading strategies. Challenges of Operating in These Ecosystems Market makers face challenges in the fast-paced Web3 environment. Keeping up with evolving technologies demands constant vigilance. Deciding which innovations to integrate requires careful consideration. Protocol risks, such as vulnerabilities in smart contracts , can jeopardize funds. Balancing innovation with security is crucial. such as vulnerabilities in smart contracts such as vulnerabilities in smart contracts The rep from Kairon Labs stated, “There is always a protocol risk, where badly developed technologies could result in loss of funds. It could be hacks, exploits, or some kind of bad code.” These teams must fully understand the smart contracts they interact with to mitigate those risks. Developing proprietary smart contracts can optimize on-chain operations, liquidity provision, and trading strategies. “UniswapV4's custom Hooks exemplify the increasing importance of smart contract expertise. Any time these teams upgrade to a newer, and hopefully better, version, there’s more risk and more complexity,” added Beke. “UniswapV4's custom Hooks exemplify the increasing importance of smart contract expertise. Any time these teams upgrade to a newer, and hopefully better, version, there’s more risk and more complexity,” On Using Data Analytics Tools and Automated Trading Systems Tracking token movements and on-chain analytics provides valuable insights. Tools like Etherscan and Chainalysis help predict market trends and avoid skewed inventories. These insights enhance decision-making and strategy formulation. Automated trading systems are a must-have for any market maker. They enable rapid trade execution, real-time market reaction, and liquidity maintenance across multiple venues. Beke added, “All of these systems and tools are crucial in the Web3 space. They help market makers manage complex trading strategies and reduce manual intervention.” Market Making Is the Epitome of Technical Trading Market makers are the backbone of liquidity and price stability in the rapidly evolving Web3 landscape. Their reliance on technical analysis and a range of key metrics is essential for navigating the complexities introduced by decentralized environments. As they pivot between traditional and innovative strategies, these teams must remain vigilant in adapting to new technologies while balancing security and protocol risks. Advanced data analytics tools and automated trading systems streamline their operations and enhance their ability to respond swiftly to market movements. Ultimately, the successful adaptation to these challenges will determine the continued relevance and effectiveness of market makers in the dynamic crypto realm. Thanks to the Kairon Labs team for their participation.

How Market Makers Navigating the Web3 Landscape With Technical Precision

Every tech company in the world has a software development team, and right now, 70% of them are considering how to use AI tools in the development process itself. Should they integrate AI co-pilots, outsource parts of the work to code generators, or develop bespoke tools in-house? One of the key determinants in this process is, simply - whether the tool is leading to positive results. For this, you need to run a proof of concept, while measuring team performance over time. The problem is that the old technologies developers use to track performance are 2D in their insights. New technologies are revolutionizing how engineers assess their team’s success. The old guard of performance trackers are known as management systems or engineering management platforms (EMPs) - think Jira or Azure DevOps Boards. But a new iteration is emerging with one crucial additional layer: intelligence. Software Engineering Intelligence Platforms (SEIPs) are like EMPs with an added element of intelligent data gathering and analysis. They track performance not just based on task completion. Instead, they leverage multiple data sources, create unique metrics using aggregated data, carry out complex analyses, and have predictive capabilities. It is these 3D platforms that are most suited to closely measuring the success or failure of AI adoption in teams at the forefront of technological advancements. This is how SEIPs work. 1. Layered Data Points - The What EMPs are limited in their insights because of the narrow data they focus on: essentially, they can tell you about the status of a task, and the time it took to complete it. As well as these basic engineering metrics, SEIPs integrate several other layers of data. They capture all the engineers’ work across platforms: what’s happening on Jira, their activity on GitHub, what’s being recorded on DevOps tools such as Jenkins, and more. SEIPs then translate these signals into metrics to give an otherwise impossible level of insight into what’s happening within your team. If you were to assess the success of an AI product by just looking at the rate of task completion, you might reach a skewed conclusion. For example, more tasks may have been completed within the time frame. But by connecting the SEIP to other tools like Jenkins or GitHub, you may find that your Change Failure Rate (CFR) - code changes that lead to failed deployments - has simultaneously increased, creating a new vulnerability. Furthermore, unlike EMPs, SEIPs will integrate contextual data that helps to understand the value of people’s work, such as project costs and engineer salaries. That allows managers to measure the ROI and business outcomes of a specific tool you’re experimenting with. 2. Measuring the Invisible - The Where Without a SEIP, measuring the *impact *of AI deployment is extremely hard, as all you have is a black box. Today, most engineering teams’ performance is measured in ticket completion: such as how many tickets were completed in a sprint. But the productivity of AI tools can’t just be measured in tickets completed - it’s more nuanced than EMPs allow for. With SEIPs, you can quantify more than whether a team was able to complete a task, and with what speed. They can also measure the impact and quality of work, or the less “visible” elements of an engineer’s work. SEIPs look at metrics such as DORA Metrics, Cycle Time, and how much-unplanned work is being generated. This can show if work is improving, if more code is being deployed than before, and if it includes fewer failures. SEIPs can also shed light on correlations between metrics that EMPs can’t. SEIPs can also measure developer experience (DX) - an often overlooked but critical metric relating to developer well-being. This can be done by looking at specific metrics, such as deployment frequency - if this grows, it could suggest increased enthusiasm and engagement within the team. 3. Analytical Metrics - The Why EMPs can tell you that a task was completed in 5 days, rather than the benchmark of 2 days, but they can’t show you why velocity slowed down. SEIPs allow managers to zoom in on the ‘why’ metrics or causal factors: were there any bottlenecks? Did certain internal events over the past week slow down operations across the board? For example, a slowed-down sprint time after AI integration might not be due to an engineering team working more slowly, but because the code review time is way longer than the benchmark. Perhaps, the slower sprint time was due to the code reviewer being overwhelmed by the amount of new code because the AI tool increased developer output so much that they couldn’t keep up. That tells you both that the AI was successful in part and that changes are needed internally (you need more code reviewers) to make full adoption efficient. SEIPs have another important advantage - they can provide recommendations on how to improve the situation based on that same granular data. So if your AI deployment is being hindered by a specific bottleneck, the SEIP could provide recommendations to remove it and take fuller advantage of the AI tool’s benefits. 4. Internal Benchmarks - The Who It doesn’t always make sense to only compare your engineers’ work to benchmarks that are the industry standard - which is something that often occurs with EMPs. If you’re assessing the effectiveness of a new AI tool you need to make sure it’s making your team better than they were before the deployment. SEIPs gather historical data from your team in order to create internal benchmarks of what constitutes a satisfactory commit count or cycle time. It does this by reviewing previous performance and identifying in what circumstances the team performs best - all of which can provide better conditions for predicting the AI deployment’s real impact. Your AI deployment could have its greatest potential in specific areas where you’re already meeting industry benchmarks. But if you’re already hitting the industry average, you may not focus on tracking impact in that area. A SEIP could show you how the AI is making that process 200 or 300% more efficient. 5. Predictive Capabilities - The When If you want to go one step further, SEIPs also offer predictive features that can greatly speed up the proof of concept process. During a sprint, by collecting a series of metrics and comparing them to past performance and results, a SEIP can predict whether you will be able to complete the sprint by the given deadline. An EMP will tell you you’re late only after you’re already late. The benefit here for testing out new products is that it can give you far quicker insights into your experimentations. It could allow you to test multiple AI tools at once, or to cycle more quickly between AI tools to find the most effective one in a reduced amount of time. Most tech companies are moving towards adopting AI, but the current software they’re using to monitor performance simply isn’t inquisitive enough to give managers a real view of what’s working and what’s not. A new generation of SEIPs will help bridge that knowledge gap. Every tech company in the world has a software development team, and right now, 70% of them are considering how to use AI tools in the development process itself. Should they integrate AI co-pilots, outsource parts of the work to code generators, or develop bespoke tools in-house? 70% of them One of the key determinants in this process is, simply - whether the tool is leading to positive results. For this, you need to run a proof of concept, while measuring team performance over time. The problem is that the old technologies developers use to track performance are 2D in their insights. New technologies are revolutionizing how engineers assess their team’s success. The old guard of performance trackers are known as management systems or engineering management platforms (EMPs) - think Jira or Azure DevOps Boards. But a new iteration is emerging with one crucial additional layer: intelligence . intelligence Software Engineering Intelligence Platforms (SEIPs) are like EMPs with an added element of intelligent data gathering and analysis. They track performance not just based on task completion. Instead, they leverage multiple data sources, create unique metrics using aggregated data, carry out complex analyses, and have predictive capabilities. Software Engineering Intelligence Platforms (SEIPs) It is these 3D platforms that are most suited to closely measuring the success or failure of AI adoption in teams at the forefront of technological advancements. This is how SEIPs work. 1. Layered Data Points - The What 1. Layered Data Points - The What EMPs are limited in their insights because of the narrow data they focus on: essentially, they can tell you about the status of a task, and the time it took to complete it. As well as these basic engineering metrics, SEIPs integrate several other layers of data. They capture all the engineers’ work across platforms: what’s happening on Jira, their activity on GitHub, what’s being recorded on DevOps tools such as Jenkins, and more. SEIPs then translate these signals into metrics to give an otherwise impossible level of insight into what’s happening within your team. If you were to assess the success of an AI product by just looking at the rate of task completion, you might reach a skewed conclusion. For example, more tasks may have been completed within the time frame. But by connecting the SEIP to other tools like Jenkins or GitHub, you may find that your Change Failure Rate (CFR) - code changes that lead to failed deployments - has simultaneously increased, creating a new vulnerability. Furthermore, unlike EMPs, SEIPs will integrate contextual data that helps to understand the value of people’s work, such as project costs and engineer salaries. That allows managers to measure the ROI and business outcomes of a specific tool you’re experimenting with. 2. Measuring the Invisible - The Where 2. Measuring the Invisible - The Where Without a SEIP, measuring the *impact *of AI deployment is extremely hard, as all you have is a black box. Today, most engineering teams’ performance is measured in ticket completion: such as how many tickets were completed in a sprint. But the productivity of AI tools can’t just be measured in tickets completed - it’s more nuanced than EMPs allow for. With SEIPs, you can quantify more than whether a team was able to complete a task, and with what speed. They can also measure the impact and quality of work, or the less “visible” elements of an engineer’s work. SEIPs look at metrics such as DORA Metrics, Cycle Time, and how much-unplanned work is being generated. This can show if work is improving, if more code is being deployed than before, and if it includes fewer failures. SEIPs can also shed light on correlations between metrics that EMPs can’t. SEIPs can also measure developer experience (DX) - an often overlooked but critical metric relating to developer well-being. This can be done by looking at specific metrics, such as deployment frequency - if this grows, it could suggest increased enthusiasm and engagement within the team. 3. Analytical Metrics - The Why 3. Analytical Metrics - The Why EMPs can tell you that a task was completed in 5 days, rather than the benchmark of 2 days, but they can’t show you why velocity slowed down. why SEIPs allow managers to zoom in on the ‘why’ metrics or causal factors: were there any bottlenecks? Did certain internal events over the past week slow down operations across the board? For example, a slowed-down sprint time after AI integration might not be due to an engineering team working more slowly, but because the code review time is way longer than the benchmark. Perhaps, the slower sprint time was due to the code reviewer being overwhelmed by the amount of new code because the AI tool increased developer output so much that they couldn’t keep up. That tells you both that the AI was successful in part and that changes are needed internally (you need more code reviewers) to make full adoption efficient. SEIPs have another important advantage - they can provide recommendations on how to improve the situation based on that same granular data. So if your AI deployment is being hindered by a specific bottleneck, the SEIP could provide recommendations to remove it and take fuller advantage of the AI tool’s benefits. 4. Internal Benchmarks - The Who 4. Internal Benchmarks - The Who It doesn’t always make sense to only compare your engineers’ work to benchmarks that are the industry standard - which is something that often occurs with EMPs. If you’re assessing the effectiveness of a new AI tool you need to make sure it’s making your team better than they were before the deployment. SEIPs gather historical data from your team in order to create internal benchmarks of what constitutes a satisfactory commit count or cycle time. It does this by reviewing previous performance and identifying in what circumstances the team performs best - all of which can provide better conditions for predicting the AI deployment’s real impact. internal Your AI deployment could have its greatest potential in specific areas where you’re already meeting industry benchmarks. But if you’re already hitting the industry average, you may not focus on tracking impact in that area. A SEIP could show you how the AI is making that process 200 or 300% more efficient. 5. Predictive Capabilities - The When 5. Predictive Capabilities - The When If you want to go one step further, SEIPs also offer predictive features that can greatly speed up the proof of concept process. During a sprint, by collecting a series of metrics and comparing them to past performance and results, a SEIP can predict whether you will be able to complete the sprint by the given deadline. An EMP will tell you you’re late only after you’re already late. The benefit here for testing out new products is that it can give you far quicker insights into your experimentations. It could allow you to test multiple AI tools at once, or to cycle more quickly between AI tools to find the most effective one in a reduced amount of time. Most tech companies are moving towards adopting AI, but the current software they’re using to monitor performance simply isn’t inquisitive enough to give managers a real view of what’s working and what’s not. A new generation of SEIPs will help bridge that knowledge gap.

What Are SEIPs? The New Way Engineering Leaders Measure Successful AI Adoption

1:1 with Alex Roetter: Leading Engineering at Twitter

How is Software Development Analytics increasing Engineering Efficiency? How do you make “Agile” more, well, agile? Simple: You allow the data to lead the way. Twenty-five years ago, this was not even a pipedream (except, perhaps, for prescient, rockstar developers who are always looking ahead). Twenty-five years ago, we had waterfall development, changes occurring in months and even years, and private, walled-off IP. Today, we’re right on the precipice of a reality that’s more agile than Agile — as we move from Agile development and a DevOps culture to autonomous development. Today, systems are event-driven, and feedback occurs in hours, even minutes. Out here, the ability to move forward is actually decided by humans (though we’ll soon release that responsibility to AI/autonomous systems). And, in this reality, code is no longer protected — rather, it’s the tool used to coordinate people and power up great products. But the future of software development rests in a shift toward the autonomous, a context in which machines connect systems, feedback is instant, and automation goes as deep as the data does. And the arrival path to this Promised Land is paved with first increasing engineer efficiencies with data, freeing up human engineers to focus on what they do best — the work — in a . more aligned, optimized, and accurate way What Is Data-Driven Agile? Simply put, is a three-word way of describing the very real need engineering or DevOps teams (within a CI/CD lifecycle, powered by Agile processes like sprint planning) have to become more streamlined over time. data-driven Agile In short, these teams have an increasing need to measure and improve their performance with the power of real-time, objective metrics and reports. The data should (and does) come from Git repositories, and organizing this data gives teams insights into “where to cut the gravy train,” so to speak. Unlike Waterfall’s fall (pun intended) and the eventual adoption of Agile methodology, data-driven Agile is more than just agile. In fact, it adds a layer of quality control and measurement to the processes of an Agile development team rather than entirely supplanting the approach. And that’s how you should think about the benefits it brings. See, if you’ve been reading the tea leaves over the developer-led landscape in the past decade, you already know that the moment of Agile’s own evolution was inevitable. It’s not simply because Agile, as a philosophy, drives toward progressive iteration — a concept widely embraced in everything from software development to human development (think, for building habits). James Clear’s 1% improvement It’s also not simply because the that essentially labels technology and software as critical components of public infrastructure. United States Senate passed a bill And, it’s certainly not only because we’re doing away with what Harvard identified as the “ ” — also known as HiPPOs — for decision-making and, instead, allowing data-driven decision-making to lead the way. Highest Paid People’s Opinions An example of this is their engineering teams’ output. By eliminating self-reporting, software engineering managers could gain granular visibility and truly objective data. Tata Health’s method of collecting data about They then used this data to optimize the decision-making process and help them identify growth opportunities for their team members. All of the above shifts are pieces of the puzzle, certainly. But, together, they still don’t entirely complete the picture. The fact is that our move toward a data-driven approach must hit Agile and transform it because there’s a very real problem to be solved: Now more than ever, engineering teams and the development lifecycle need insight and intelligence to support sustainable development, autonomous teams, and aligned business decisions. For example, one of (old) Agile’s key principles was “Simplicity is essential.” That means, where possible, maximize the amount of work not done (because it didn’t have to be done). The “new,” data-driven Agile agrees with simplicity, keeps it intact, but adds a layer: “Optimize the work in progress.” Doing so is absolutely crucial because it allows engineering leaders to spot and eliminate places where the development lifecycle is getting bogged down. Essentially, what has become clear as we shift into this “new,” more agile Agile is that there’s a clear line in the sand: the “old” Agile processes worked when Agile was the new kid on the block, and developer-led tools, platforms, and techniques were an exception. But the global demand for digital services, though ever-increasing, has been here for over a decade. So we’re now in an age where there’s an increased and real need for anything that can improve the velocity of software development while reducing the risk of burnout. And that’s where data-driven engineering leadership can transform everything from how managers communicate and offer feedback (through one-to-ones, supported by individual data and reports) to how frequently software is deployed (i.e., with a steady cadence). How Dev Analytics Increase Engineering Efficiency The data-driven Agile method delivers three significant whammies: , it generates objective reports about the software’s dev cycle, without the need for manual input from engineers. First , it does so by analyzing codebase, pull requests, and tickets to collect raw data and improve engineering efficiency. Second And, , this data, over time, empowers data-driven innovation, feedback, and leadership when it comes to better software deployed at a greater velocity. third Measuring Engineering Performance Where It Truly Matters Show, not tell — that’s what data-driven engineering management empowers, and that’s what dev analytics platforms’ functionality focuses on. So, let’s take a look at an engineering KPI measured by software development analytics platforms: . Impact One aspect of developer or engineer productivity is to look beyond the lines of code when measuring code activity. “Impact” gives engineering management a clear way to do that. As a metric we came up with, it includes multiple data points such as: Ratio of old code edits to total work done Number of edit locations (Can code get more efficient?) Number of affected files (Do we have bloat somewhere in the pipeline?) Severity of changes to old code (Did we fail to conceive of an issue in our initial code deployment? Are user stories accurately aligned with feature requests? etc.) Historical code changes So, the end result of this type of data is pretty powerful because not only does it amplify the magnitude of code changes, but it also ultimately gets engineering teams to take a critical stance on their own processes when reviewing that data. Ideally, the intelligence and insights from data-driven Agile can help engineering leadership create a new baseline for development metrics. In the short term, what it can tangibly improve is software delivery and code accuracy. Greater Visibility Equals Better Product Quality Being a product-first software company with product-led growth is precisely the way it should be — this is one of the most significant transformations of a developer-led landscape in the past decade and a half. However, product-led growth is only as good as the processes that support it and the engineers who build it. The sophistication of the developer-led software market has also increased the pace of software development. Teams need to code faster, deliver features more quickly, and constantly update or modify their code while gaining clear insight into the nature of the changes. The result is that changes can become opaque. It’s almost impossible to, for example, check to see if all code areas have been tested. It’s highly plausible, and even likely that this lack of visibility then means risking the release of buggy, sub-optimal software. Instead, reports like are essential to gaining deeper insight and visibility into the signals of notorious process blockers. With an emphasis on the following metrics, teams can gain clarity about how to evaluate performance: Project Timeline Commits volume Average number of commits per team Total impact of changes to the codebase …and more. Accelerates Overall Velocity of Production Let’s take a look at this situation: If you’re not only aiming toward but actually implementing an environment that is dedicated to increasing software production velocity, you’ll likely experience two specific instances: First off, Scrum teams might combine business analysis, development, and testing. Everyone becomes responsible for delivering high-quality software. This also means everyone is accountable in the event of production issues. Conversely, shorter development cycles, faster releases, and early bug detection also mean a loss of control and visibility. Integrated teams mean engineering management has little insight into the status of the product. And this begs the question: can you accelerate velocity as an end goal while still maintaining transparency? The answer is, of course, that you can — with the right tools. The key lies in the processes, the details of data-driven decisions. Implementing a data-driven Agile approach means you’re also opening the door to a data-driven Scrum framework. On the surface, it seems as though “extra” data complexifies things like sprint planning and execution. But, the right data about performance and productivity, coupled with real-time, objective reporting, actually helps to eliminate the ambiguities in the development process. You’ll still be able to maintain smaller iterations, conduct daily Scrum meetings, and participate in sprint reviews. But adding data to back these up means you can eliminate some of the real issues with Scrum and Kanban. Instead, you’ll have a framework that allows teams to “follow the data” to the highest priority tasks (and effectively reprioritize tasks where necessary). If it’s necessary, for example, to implement an iteration that lasts a day rather than three weeks (and vice versa), the data justifies that flexibility. You need not stick to Scrum’s fixed-length sprints. Data-Driven Scrum also resolves the issue of inherently unreliable task estimation because you have real data to back up precisely how much time tasks take. These are the granular details that significantly improve a development team’s process. This gushes up for the ultimate alignment between a production team’s outcomes and business priorities. In other words, why we’re doing the work and how we’re doing the work are in harmony when data is around. Conclusion One major takeaway that should be really clear is how software development analytics starts off by increasing engineering efficiency — i.e., improvements to process — but what it really supports is a better team and peer-to-peer collaboration. Development analytics platforms essentially pave the way for autonomous software engineering teams because there’s first a culture of autonomy. In other words, before software development can become autonomous, we need teams to be autonomous. And teams can do that when they have reliable, specific data to back up their decisions and actions. When you’re ready to translate data into greater visibility, and this visibility into faster, more efficient teams, you can start looking at . development dora metrics analytics platforms like Waydev Also Published At: https://waydev.co/increasing-engineering-efficiency/

Increasing Engineering Efficiency with Software Development Analytics

Photo by on Mick De Paola Unsplash The “Maybe just a quick one” series title is inspired by my most common reply to “Fancy a drink?”, which, may or may not end up in a long night. Likewise, these posts are intended to be short but I get carried away sometimes, so, apologies in advance. About 🤗 Transformers 🤗 Transformers ( ) is a collection of state-of-the-art NLU (Natural Language Understanding) and NLG (Natural Language Generation ) models.  They offer a wide variety of architectures to choose from (BERT, GPT-2, RoBERTa etc) as well as a of pre-trained models uploaded by users and organisations. Hugging Face transformers hub Fine-tuning a model One of the things that makes this library such a powerful tool is that we can use the models as a basis for tasks. In other words, they can be a starting point to apply some fine-tuning using our own data. The library is designed to easily work with both Tensorflow or PyTorch. transfer learning 🤗 Datasets is a  wrapper library that provides some tools to load and process data in many commonly used formats (CSV, JSON etc). It also makes sharing datasets and metrics for Natural Language Processing extremely easy. Hugging Face Datasets 🤗 Datasets originated from a fork of the awesome TensorFlow Datasets and the HuggingFace team want to deeply thank the TensorFlow Datasets team for building this amazing library. Well, let’s write some code In this example, we will start with  a pre-trained model and fine-tune it on the dataset. We will then test it  on classifying tweets as hate speech, offensive language, or neither. All coding is done in . BERT (uncased) Hate Speech and Offensive Language Google Colab Please note:  this dataset contains text that can be considered racist, sexist, homophobic, or generally offensive. So let’s start by installing some necessary packages, import them and load the dataset. The dataset is stored in Google Drive, and the path to load it from is . So if you code along , please make sure you change the path to point to your own dataset file. /content/drive/MyDrive/Data/labeled_data.csv We are using the function to load it and then split it into train, validation, and test sets. The 3 sets are then gathered together to form a .This is a dictionary class, that offers us many methods to process the data. We will then remove some of the columns we don’t need for our classification task. load_dataset DatasetDict !pip install transformers
!pip install datasets datasets load_dataset,DatasetDict transformers AutoTokenizer,TFAutoModelForSequenceClassification tensorflow tf numpy np matplotlib.pyplot plt

The dataset located our Google Drive data folder.

DATA_PATH = dataset = load_dataset( , data_files=DATA_PATH,split= )
train_testvalid = dataset.train_test_split()
test_valid = train_testvalid[ ].train_test_split()
train_test_valid_dataset = DatasetDict({ : train_testvalid[ ], : test_valid[ ], : test_valid[ ]})
dataset = train_test_valid_dataset.remove_columns([ , , , , ]) #Install the necessary packages from import from import import as import as import as is in "/content/drive/MyDrive/Data/labeled_data.csv" 'csv' 'train' 'test' 'train' 'train' 'test' 'test' 'valid' 'train' 'hate_speech' 'offensive_language' 'neither' 'Unnamed: 0' 'count' So now we need to preprocess the data. The tool responsible for this is a What do tokenizers do? Very simply put, they split the data in tokens (these can be characters, words, part of words, depending on the model), and convert them into tensors of numeric ids, which is the form that the model can read. For this task, we are using the tokenizer from the pre-trained model we selected ( ). But let’s see how we achieve this: Tokenizer. bert-base-cased tokenizer = AutoTokenizer.from_pretrained( ) tokenizer(examples[ ], padding= , truncation= )

tokenized_datasets = dataset.map(tokenize_function, batched= )
train_dataset = tokenized_datasets[ ]
eval_dataset = tokenized_datasets[ ]
test_dataset = tokenized_datasets[ ]
tf_train_dataset = train_dataset.remove_columns([ ]).with_format( )
tf_eval_dataset = eval_dataset.remove_columns([ ]).with_format( )
tf_test_dataset = test_dataset.remove_columns([ ]).with_format( )

train_features = {x: tf_train_dataset[x].to_tensor() x tokenizer.model_input_names}
train_tf_dataset = tf.data.Dataset.from_tensor_slices((train_features, tf_train_dataset[ ]))
train_tf_dataset = train_tf_dataset.shuffle(len(tf_train_dataset)).batch( )

eval_features = {x: tf_eval_dataset[x].to_tensor() x tokenizer.model_input_names}
eval_tf_dataset = tf.data.Dataset.from_tensor_slices((eval_features, tf_eval_dataset[ ]))
eval_tf_dataset = eval_tf_dataset.batch( )

test_features = {x: tf_test_dataset[x].to_tensor() x tokenizer.model_input_names}
test_tf_dataset = tf.data.Dataset.from_tensor_slices((test_features, tf_test_dataset[ ]))
test_tf_dataset =test_tf_dataset.batch( ) "bert-base-cased" : def tokenize_function (examples) return "tweet" "max_length" True True "train" "valid" 'test' "tweet" "tensorflow" "tweet" "tensorflow" "tweet" "tensorflow" for in "class" 8 for in "class" 8 for in "class" 8 Notice how we used the dataset function, to apply our user-defined to all the elements of the dataset. map tokenize_function After applying the tokenization, we created 3 to feed the model with. We are now ready to train the model. Again, we are using the selected pre-trained model, transferring the “knowledge” it already has, but replacing its head with one that is suited to our task. We are using the class, which represents a generic Tensorflow (hence the TF prefix) model, with a sequence classification head. Also, notice the num_labels parameter which is set to 3, as this is a multi-class task with 3 distinct labels. After the training is finished, we plot the Sparse Categorical Accuracy and the Loss of both the train and the validation dataset. Tensorflow Datasets TFAutoModelForSequenceClassification model = TFAutoModelForSequenceClassification.from_pretrained( , num_labels= )
model.compile(
    optimizer=tf.keras.optimizers.Adam(learning_rate= ),
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits= ),
    metrics=tf.metrics.SparseCategoricalAccuracy(),
)

history = model.fit(train_tf_dataset, validation_data=eval_tf_dataset, epochs= )

plt.plot(history.history[ ])
plt.plot(history.history[ ])
plt.title( )
plt.ylabel( )
plt.xlabel( )
plt.legend([ , ], loc= )
plt.show()
plt.plot(history.history[ ])
plt.plot(history.history[ ])
plt.title( )
plt.ylabel( )
plt.xlabel( )
plt.legend([ , ], loc= )
plt.show() "bert-base-cased" 3 5e-5 True 2 'sparse_categorical_accuracy' 'val_sparse_categorical_accuracy' 'model sparse categorical accuracy' 'accuracy' 'epoch' 'train' 'val' 'upper left' 'loss' 'val_loss' 'model loss' 'loss' 'epoch' 'train' 'val' 'upper left' We can now evaluate the model on the test dataset we created earlier: test_loss, test_acc = model.evaluate(test_tf_dataset,verbose= )
print( , test_acc) / - s - loss: - sparse_categorical_accuracy: Test accuracy: model.save_pretrained( ) 2 '\nTest accuracy:' 194 194 62 0.2596 0.9135 0.9134925603866577 "/content/drive/MyDrive/Data/hate-speech-bert" Notice that we save the model with the function offered by Transformers. This action generates a directory with two files by default: a .json file that contains the model configuration and a .h5 file with the model weights. We can also push the model to the Hugging Face Models Hub should we want to, in order to make it available to the public. save_pretrained Does it work though? Let’s see how our model does in classifying some unseen text. I will use some stereotypical racist/offensive/sexist texts posted on social media. : Warning Due to the nature of this task, the language used here can be racist, sexist, and offensive. However, this is the only way to evaluate the model’s ability. pred2label = { : , : , : }
preds = model(tokenizer([ , , ],return_tensors= ,padding=True,truncation=True))[ ]
print(preds)
class_preds = np.argmax(preds, axis= ) pred class_preds:
  print(pred2label[pred]) 0 'Hate Speech' 1 'Offensive Language' 2 'Neither' "Jews are useless , I don't see why they even exist" "Gay people suck" "Women are dressed up like whores these days" "tf" 'logits' 1 for in tf.Tensor(
[[ ]
 [ ]
 [ ]], shape=( , ), dtype=float32)
Hate Speech
Hate Speech
Offensive Language 0.37532297 0.14053927 -0.8647832 0.04699412 -0.17951615 -0.3738104 0.2524849 2.586107 -2.8212454 3 3 Looks like our model managed to correctly (well that’s subjective, but generally speaking these look correct) classify the texts. Further reading: If the above seems interesting to you, there is a lot more that this library can do. I would start by checking their documentation which is quite extensive as well as some quick video courses they provide: 🤗 Transformers Model Hub 🤗 Datasets (with Youtube Videos, we always like them ) Crash course Fine-tuning with custom datasets Happy coding.

How to Fine Tune a 🤗 (Hugging Face) Transformer Model

Sentiment analysis is a technique used to determine if data is , , or . Natural Language Processing (NLP) positive negative neutral Sentiment analysis is fundamental, as it helps to understand the emotional tones within language. This, in turn, helps to automatically sort the opinions behind reviews, social media discussions, etc., allowing you to make faster, more accurate decisions. Although sentiment analysis has become extremely popular in recent times, work on it has been progressing since the early 2000s. Traditional machine learning methods such as Naive Bayesian, Logistic Regression, and Support Vector Machines (SVMs) are widely used for large-scale sentiment analysis because they scale well. Deep learning (DL) techniques have now been proven to provide better accuracy for various NLP tasks, including sentiment analysis; however, they tend to be slower and more expensive to learn and use. In this story, I want to offer a little-known alternative that combines speed and quality. For conclusions and assessments of the proposed method, I need a baseline model. I chose the time-tested and popular BERT. Getting the Data Social media is a source that produces a massive amount of data on an unprecedented scale. The dataset I will be using for this story is . Coronavirus tweets NLP As I can see, there is not so much data for the model, and at first glance, it seems that one cannot do without a pre-trained model. Due to the small number of samples for training, I reduce the number of classes to 3 by combining them. Baseline BERT Model Let’s use TensorFlow Hub. TensorFlow Hub is a repository of trained machine learning models ready for fine-tuning and deployable anywhere. You can use trained models like BERT and Faster R-CNN with just a few lines of code. !pip install tensorflow_hub
!pip install tensorflow_text Smaller BERT model. small_bert/bert_en_uncased_L-4_H-512_A-8 — This is one of the smaller BERT models referenced in . The smaller BERT models are intended for environments with restricted computational resources. They can be fine-tuned in the same manner as the original BERT models. However, they are most effective in the context of knowledge distillation, where a larger and more accurate teacher produces the fine-tuning labels. Well-Read Students Learn Better: On the Importance of Pre-training Compact Models Text preprocessing for BERT. This model uses a vocabulary for English extracted from Wikipedia and BooksCorpus. Text inputs have been normalized the “uncased” way, meaning that the text has been lower-cased before tokenization into word pieces, and any accent markers have been stripped. bert_en_uncased_preprocess — tfhub_handle_encoder = \ tfhub_handle_preprocess = \ "https://tfhub.dev/tensorflow/small_bert/bert_en_uncased_L-4_H-512_A-8/1" "https://tfhub.dev/tensorflow/bert_en_uncased_preprocess/3" I will not make the selection of parameters and optimization in order not to complicate the code. All the same, this is the baseline model, not SOTA. def build_classifier_model():
    
    text_input = tf.keras.layers.Input(
        shape=(), dtype=tf.string, name= )
    
    preprocessing_layer = hub.KerasLayer(
        tfhub_handle_preprocess, name= )
    
    encoder_inputs = preprocessing_layer(text_input)
    encoder = hub.KerasLayer(
        tfhub_handle_encoder, trainable=True, name= )
    
    outputs = encoder(encoder_inputs)
    net = outputs[ ]
    net = tf.keras.layers.Dropout( )(net)
    net = tf.keras.layers.Dense( , activation= , name= )(net)
    model = tf.keras.Model(text_input, net)
    
    loss = tf.keras.losses.CategoricalCrossentropy(from_logits=True)
    metric = tf.metrics.CategoricalAccuracy( )
    optimizer = Adam(
        learning_rate= , epsilon= , decay= , clipnorm= )
    model.compile(
        optimizer=optimizer, loss=loss, metrics=metric)
    model.summary() model 'text' 'preprocessing' 'BERT_encoder' 'pooled_output' 0.1 3 'softmax' 'classifier' 'accuracy' 5e-05 1e-08 0.01 1.0 return I have created a model with just under 30M parameters. I allocated 30 percent of the data for model validation. train train, valid = train_test_split(
    df_train,
    train_size= ,
    random_state= ,
    stratify=df_train[ ])
y_train, X_train = \
    train[ ], train.drop([ ], axis= )
y_valid, X_valid = \
    valid[ ], valid.drop([ ], axis= )
y_train_c = tf.keras.utils.to_categorical(
    y_train.astype( ).cat.codes.values, num_classes= )
y_valid_c = tf.keras.utils.to_categorical(
    y_valid.astype( ).cat.codes.values, num_classes= ) 0.7 0 'Sentiment' 'Sentiment' 'Sentiment' 1 'Sentiment' 'Sentiment' 1 'category' 3 'category' 3 The number of epochs was chosen intuitively and did not require justification :) history = classifier_model.fit(
    x=X_train[ ].values,
    y=y_train_c,
    validation_data=(X_valid[ ].values, y_valid_c),
    epochs= ) 'Tweet' 'Tweet' 5 BERT Accuracy: 0.833859920501709 Confusion Matrix: Classification Report: Here I have the baseline model. Obviously, I can improve this model further. But let’s leave this task as your homework. CatBoost Model is a high-performance, open-source library for gradient boosting on decision trees. From release 0.19.1, it supports text features for classification on GPU out-of-the-box. CatBoost The main advantage is that CatBoost can include categorical functions and text functions in your data without additional preprocessing. For those who value inference speed — CatBoost predictions are 20 to 40 times faster than other open-source gradient boosting libraries, making CatBoost useful for latency-critical tasks. !pip install catboost I will not select the optimal parameters; let that be your other homework. Let’s write a function to initialize and train the model. def fit_model(train_pool, test_pool, **kwargs):
    model = CatBoostClassifier(
        task_type= ,
        iterations= ,
        eval_metric= ,
        od_type= ,
        od_wait= ,
        **kwargs
    ) model.fit(
        train_pool,
        eval_set=test_pool,
        verbose= ,
        plot=True,
        use_best_model=True) 'GPU' 5000 'Accuracy' 'Iter' 500 return 100 When working with CatBoost, I recommend using a . The Pool is a convenience wrapper combining features, labels, and further metadata like categorical and text features. Pool train_pool = Pool(
    data=X_train,
    label=y_train,
    text_features=[ ]
)
valid_pool = Pool(
    data=X_valid, 
    label=y_valid,
    text_features=[ ]
) 'Tweet' 'Tweet' text_features — A one-dimensional array of text columns indices (specified as integers) or names (specified as strings). Use only if the data parameter is a two-dimensional feature matrix (has one of the following types: list, numpy.ndarray, pandas.DataFrame, pandas.Series). If any elements in this array are specified as names instead of indices, names for all columns must be provided. To do this, either use the feature_names parameter of this constructor to explicitly specify them or pass a pandas.DataFrame with column names specified in the data parameter. Supported : training parameters — Tokenizers are used to preprocess Text type feature columns before creating the dictionary. tokenizers Dictionaries used to preprocess Text type feature columns. dictionaries — Feature calcers used to calculate new features based on preprocessed Text type feature columns. feature_calcers — I set all the parameters intuitively; tuning them will be your homework again. model = fit_model(
    train_pool, valid_pool,
    learning_rate= ,
    tokenizers=[
        { : , : , : , :[ , , ], : }      
    ],
    dictionaries = [
        { : , : }
    ],
    feature_calcers = [ ]
) 0.35 'tokenizer_id' 'Sense' 'separator_type' 'BySense' 'lowercasing' 'True' 'token_types' 'Word' 'Number' 'SentenceBreak' 'sub_tokens_policy' 'SeveralTokens' 'dictionary_id' 'Word' 'max_dictionary_size' '50000' 'BoW:top_tokens_count=10000' Accuracy: Loss: CatBoost model accuracy: 0.8299104791995787 Confusion Matrix: Classification Report: The result is very close to what the baseline BERT model has shown. Because I have very little data for training, and the model was taught from scratch, the result is, in my opinion, impressive. Bonus I got two models with very similar results. Can this give us anything else useful? Both models have little in common at their core, which means that their combination should give a synergistic effect. The easiest way to test this conclusion is to average the result and see what happens. y_proba_avg = np.argmax((y_proba_cb + y_proba_bert)/ , axis= ) 2 1 The gain is impressive. Average accuracy: 0.855713533438652 Confusion Matrix: Classification Report: Summary In this story, I: created a baseline model using BERT; created a model with CatBoost using built-in text capabilities; looked at what happens if average the result from both models. In my opinion, complex and slow SOTAs can be avoided in most cases, especially if speed is a critical need. CatBoost provides great sentiment analysis capabilities right out of the box. For competition lovers like , , etc., CatBoost can provide a good model both as a baseline solution and as a part of an ensemble of models. Kaggle DrivenData The code from the story can be viewed . here

Unconventional Sentiment Analysis: BERT vs. Catboost

Stories, News & Mentions about 24METRICS

24metrics’s Stories on HackerNoon