In 2012, our five entrepreneurs asked themselves \"why is it easier to get unbiased information about a $100 hotel room than a $100,000 piece of software?\" The next day, we founded G2

The Business 20 (B20) India Communique recommends that Group of 20 (G20) nations should promote interoperable digital identities at the individual, enterprise, and farm levels. Following the B20 India Summit last weekend, the leaders of the B20 published their , with a section dedicated to what they call (DPI) rollouts. annual communique digital public infrastructure Although the communique does not define DPI, and in fact calls on G20 nations to develop a definition for it, we know that it has to do with digital identity, , and mobile services. financial services We know as much because India’s digital ID architect, Nandan Nilekani, told the International Monetary Fund (IMF) last April that those were the during a panel called . three tools of the new world Digital Public Infrastructure: Stacking Up the Benefits “If you think, ‘what are the tools of the New World?‘ — Everybody should have a digital ID; everybody should have a bank account; everybody should have a smartphone. Then, anything can be done. Everything else is built on that” Nandan Nilekani, IMF Spring Meetings, April 2023 https://twitter.com/TimHinchliffe/status/1648733976687673362?embedable=true Fast forward to August, and the B20 communique calls on G20 nations to rollout DPI, with the first policy action being to: “ “ Promote the digitization of identities at the individual, enterprise, and farm levels that are both interoperable and recognized across borders B20 India Communique, August 2023 As a key performance indicator (KPI) for digital ID rollouts, the B20 recommends: “G20 nations to develop guidelines for unique single digital identification for MSME [micro, small and medium-sized enterprises] and individuals that can be securely accessed (based on consent) by different government and private stakeholders for identity verification and information access within 3 years” B20 India Communique, August 2023 Notice that this digital identity is not just for identity verification, but is also for “governments and private stakeholders” to have access to other types of , including your health records, business dealings, land use, consumption habits, and finances. information about you This type of digital identity is precisely what the (WEF) has been pushing, and it is a major component of the so-called fourth industrial revolution that WEF founder and great reset architect Klaus Schwab says will lead to the fusion of our physical, biological, and digital identities. World Economic Forum “ “ This digital identity determines what products, services and information we can access – or, conversely, what is closed off to us World Economic Forum, 2018 “G20 nations to develop a framework to digitize the agricultural value chain to enhance credit access by leveraging alternate farm/ livelihood data within 3 years” B20 India Communique, 2023 https://twitter.com/TimHinchliffe/status/1696590065328165040?embedable=true Other DPI policy actions recommended in the B20 India Communique have to do with digital payment systems, data flows, technology standards, and public-private partnerships — the fusion of corporation and state — which is the modus operandi of the WEF. Policy action 2.2: Encourage the development of DPI with safeguards for seamless delivery of public services. : Private sector and G20 governments to develop a definition of DPI and a list of DPI use cases that showcase global examples of DPI within 2 years. KPIs Within 2 years, G20 nations to adopt a governance framework for DPI based on the following core principles: targeted scoping, transparent governance, privacy and trust, equal access, commercial sustainability, and multi-stakeholder standard setting. G20 nations to develop the guidelines for safeguarding the consumer/beneficiary data in the DPI within 2 years. Policy action 2.3: Encourage collaborations between the public and private sectors to enable digital payments and promote last-mile financial inclusion. : Financial Services regulators from the G20 nations to agree on a framework that incentivizes private sector participation in enhancing digital payments within 2 years. KPIs G20 nations to develop a concrete vision document for boosting acceptance of digital and online payments in low-connectivity areas within 3 years. . Policy action 2.4: Encourage the free data flow between financial institutions and consumers through a dedicated consent architecture : G20 governments agree to host an innovation symposium exploring private and public efforts to promote data sharing (open banking, account aggregator framework, etc.) and define best practices within 1 year. KPIs . Policy action 2.5: Promote interoperability among multiple technologies, and regulatory and financial ecosystems, enabling all stakeholders to interact : G20 governments should lead a multi-stakeholder consultation process to define technology standards and frameworks that can help facilitate interoperability within 3 years. KPIs “ “ Roll out digital public infrastructure to boost financial inclusion and healthcare access B20 India Communique, August 2023 https://twitter.com/TimHinchliffe/status/1696585169690415582?embedable=true Last year’s B20 Summit in Bali, Indonesia called on G20 nations to and to promote digital identity schemes. adopt vaccine passports using WHO standards Three days later, the G20 Bali Leaders Declaration was published, stating, “ .” We support […] efforts to strengthen prevention and response to future pandemics that should capitalize and build on the success of the existing standards and digital COVID-19 certificates This year’s B20 India Communique recommends that G20 nations develop digital ID frameworks for people, businesses, and farms within the next three years, with all data flowing freely across borders between powerful public and private entities. Will the G20 once again rubber-stamp B20 on digital ID? policy recommendations We’ll soon find out after the G20 India Summit concludes on September 10. The B20 is the official G20 dialogue forum with the global business community, and it is tasked with formulating policy recommendations on designated issues. The recommendations are then delivered to the G20 Presidency at the B20 Summit, which takes place around the G20 Summit. The G20 is a forum with some of the world’s largest economies, as well as the European Union. comprising nineteen countries The countries are Argentina, Australia, Brazil, Canada, China, France, Germany, India, Indonesia, Italy, Japan, Mexico, Russia, Saudi Arabia, South Africa, South Korea, Turkey, the United Kingdom, and the United States. Spain is invited as a permanent guest, according to the . Council on Foreign Relations This article was originally published by on Tim Hinchliffe The Sociable.

B20 Recommends G20 Promotion of Digital ID at Individual, Enterprise & Farm Levels

For fulfilling fluid gaming, our KickoffTech gaming experts recommend a with a high refresh rate (like 144Hz). We have reviewed hundreds of such high-end models, and our focus today will be on AOC G2460PF, a functional but complicated gaming . monitor monitor Specification A 24” screen A 1920 x 1080 native resolution 350 cd/m2 maximum brightness 1ms response time 16.7 million color support 144 Hz refresh rate 6.5kg weight 1000:1 contrast ratio 22.7W power consumption 178º horizontal viewing angle 170º vertical viewing angle WLED Backlight Features & Aesthetics AOC G2460PF is a variable 144Hz refresh rate panel from AUO and has an Adaptive Sync. The monitor’s front is a quite familiar style to past AOC gaming such as the G2460PG. A dark red stripe is painted at the bottom to identify AOC G2460PF as a model that supports AMD FreeSync. “FREE SYNC 144HZ” is slapped on the left, and the monitor’s bezels’ brushed metal texture is easy to note, even though they are in real sense mate black plastic. At the top and sides, these are 0.59 inches or 15mm, and 0.94 inches or 24mm at the bottom monitors AOC G2460PF’S power state and on-screen display (OSD) are controlled by buttons close to the bottom bezel’s right side. The buttons face downwards but have labels on the front. Additionally, a small power LED is in between the “Power” and “Menu” labels, this glows green once the turns on and amber if the is on standby (power) state. monitor monitor Two 2.0 USB ports are easy-to-note on the screen’s right side. The top is colored red and supports fast charging to all the devices connected. The thinnest point of this measures 0.83 inches or 21 mm, and this lumps out further centrally and down. monitor A stand is included to give great ergonomic freedom and gamers can tilt up to five degrees forward, 22 degrees backward, and adjust the height up to 5.12inches or 130mm high.  You can also choose to swivel the up to 270 degrees right or left using the turntable on the base’s underside. Better, you can with ease adjust AOC G2460PF into portrait mode by rotating 90 degrees clockwise. monitor However, note that having this monitor in portrait orientation severely limits viewing angles. At the minimum height, this screen’s bottom edge sits 1.61 inches or 41mm above the desk, while its top edge stands 15 inches or 381 mm on top of the desk. G2460PF’srear has matte plastics all through. A brushed metal texture is evident in the central area while the rest has regular matte. The stand can attach by 100mm VESA and is easy to be unscrewed should you intend to use a mount or an alternative VESA stand. A dark red clip-on cable comes with the monitor, and this can be attached to the neck of the stand. This wraps around and can be slightly viewed from the front when the screen is high enough. AMD FreeSync Like any other high-refresh rate , AOC G2460PF comes with adaptive sync, in this case, the AMD FreeSync. FreeSync may have some problems with budget monitors, but this is not the case with this model. This is because FreeSync only works in a range of 35 to 144Hz with display ports and a range of 35 to 120Hz with HDMI - the AOC G2460PF supports this. monitor It’s also worth noting that FreeSync was recently enabled for NVIDIA GPUs. Unfortunately, AOC G2460P is not officially supported and there is hence no guarantee that it will perform well in NVIDIA GPU. Therefore, if you are using an NVIDIA GPU, a G Sync monitor would work well for you, even if it would mean spending more. Built-in Speakers AOC G2460PF has stereo speakers that each have a 2W RMS, and this is the essential standard on monitor speakers. While these speakers are a convenient feature, they are not that great. For a better gaming experience, you might need to have dedicated speakers. Pros A wide FreeSync range A fast 144 Hz panel featuring a response time of 1ms. A solid and easy-to-adjust stand Decent color accuracy Compatible with VESA High value for money Cons The design doesn’t agree with everyone Viewing angles and color are not as good as VA/IPS Bottom Line AOC G2460PF is one of the reliable and highly responsive monitors and gives you the kind of fluidity that’s hard to find on regular monitors or TVs. Moreover, its FreeSync is well implemented and works great in a wide range of FPS. That combined with the 1ms response time makes this a worthy purchase. However, if you want to see our top budget gaming monitor picks for 2019, you can click on this link: best gaming monitor under 200 usd .

AOC G2460PF Review: A Great But Complicated Budget Gaming Monitor

Focus on countering radicalization conducive to terrorism and the use of Internet for terrorist purposes. At the G20 summit in Hamburg, Germany the leaders of the 20 most industrialized nations have vowed to work with Silicon Valley and technology companies to fight terrorist’s propaganda online and to amplify positive voices on the Internet. “Our counterterrorism actions must continue to be part of a comprehensive approach, including combatting radicalization and recruitment, hampering terrorist movements and countering terrorist propaganda,” a . G20 statement reads “We will exchange best practices on preventing and countering terrorism and violent extremism conducive to terrorism, national strategies and deradicalisation and disengagement programmes, and the promotion of strategic communications as well as robust and positive narratives to counter terrorist propaganda.” The G20 leaders stressed the importance of comprehensively addressing the underlying conditions that terrorists exploit and promoting political and religious tolerance, economic development, and social cohesion and inclusiveness, to resolve armed conflicts, and to facilitate reintegration. Sharing information and best practices is key: “We will share knowledge on concrete measures to address threats from returning foreign terrorist fighters and home-grown radicalised individuals. We will also share best practices on deradicalisation and reintegration programmes including with respect to prisoners.” The role of the private sector is also key to fight exploitation of the internet and social media for terrorist purposes such as propaganda, funding and planning of terrorist acts, inciting terrorism, radicalizing and recruiting to commit acts of terrorism, while fully respecting human rights. “Appropriate filtering, detecting and removing of content that incites terrorist acts is crucial in this respect,” the statement reads. The G20 leaders encourage the tech industry “to continue investing in technology and human capital to aid in the detection as well as swift and permanent removal of terrorist content.” They added: “In line with the expectations of our peoples we also encourage collaboration with industry to provide lawful and non-arbitrary access to available information where access is necessary for the protection of national security against terrorist threats.” We affirm that the rule of law applies online as well as it does offline. In May, the leaders of the G7 also called upon the tech industry to intensify their fight against terrorism online. “While being one of the most important technological achievements in the last decades, the Internet has also proven to be a powerful tool for terrorist purposes,” read a G7 joint statement on the fight against terrorism and violent extremism that came out of the first day of the G7 Summit in Taormina, Sicily. _The G7 leaders gathered in Taormina, Italy on May 26–27 for the 2017 G7 Summit._hackernoon.com G7 calls for tech groups to fight terrorism online We encourage industry to act urgently in developing and sharing new technology and tools to improve the automatic detection of content promoting incitement to violence, and we commit to supporting industry efforts in this vein including the proposed industry-led forum for combatting online extremism. _At the G7 Summit in Italy, the G7 leaders condemned “in the strongest possible terms terrorism in all its forms and…_medium.com G7 statement on the fight against terrorism and violent extremism The G7 leaders highlighted the need “to support the promotion of alternative and positive narratives rooted in our common values and with due respect to the principle of freedom of expression.”

G20 vows to work with tech groups to fight terrorism

The Ultimate List of G2Crowd Alternatives and How To Select the Right Ones for Your SaaS

The Power of User Feedback in Product Development

Simple Bar Charts in Python Based on Tabular Data import matplotlib.pyplot as plt
import pandas as pd

df = pd.DataFrame({'x': ['A', 'B', 'C', 'D', 'E'],
                   'y': [50, 30, 70, 80, 60]})

plt.bar(df['x'], df['y'], align='center', width=0.5, color='b', label='data')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.title('Bar chart')
plt.legend()
plt.show() Stacked bar chart in Python Based on Tabular Data import matplotlib.pyplot as plt
import pandas as pd

df = pd.DataFrame({'x': ['A', 'B', 'C', 'D', 'E'],
                   'y1': [50, 30, 70, 80, 60],
                   'y2': [20, 40, 10, 50, 30]})

plt.bar(df['x'], df['y1'], align='center', width=0.5, color='b', label='Series 1')
plt.bar(df['x'], df['y2'], bottom=df['y1'], align='center', width=0.5, color='g', label='Series 2')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.title('Stacked Bar Chart')
plt.legend()
plt.show() Grouped bar chart based on Tabular Data in Python import matplotlib.pyplot as plt
import pandas as pd
import numpy as np

# Prepare the data
df = pd.DataFrame({
    'group': ['G1', 'G2', 'G3', 'G4', 'G5'],
    'men_means': [20, 35, 30, 35, 27],
    'women_means': [25, 32, 34, 20, 25]
})
ind = np.arange(len(df))  # x-axis position
width = 0.35  # width of each bar

# Plot the bar chart
fig, ax = plt.subplots()
rects1 = ax.bar(ind, df['men_means'], width, color='r')
rects2 = ax.bar(ind + width, df['women_means'], width, color='y')

# Add labels, legend, and axis labels
ax.set_xticks(ind + width / 2)
ax.set_xticklabels(df['group'])
ax.legend((rects1[0], rects2[0]), ('Men', 'Women'))
ax.set_xlabel('Groups')
ax.set_ylabel('Scores')

# Display the plot
plt.show() Percent stacked bar chart based on Tabular Data in Python import matplotlib.pyplot as plt
import pandas as pd

# Prepare the data
df = pd.DataFrame({
    'x': ['Group 1', 'Group 2', 'Group 3', 'Group 4', 'Group 5'],
    'y1': [10, 20, 30, 25, 30],
    'y2': [20, 25, 30, 15, 20],
    'y3': [30, 30, 25, 20, 10]
})

# calculate percentage
y_percent = df.iloc[:, 1:].div(df.iloc[:, 1:].sum(axis=1), axis=0) * 100

# plot the chart
fig, ax = plt.subplots()
ax.bar(df['x'], y_percent.iloc[:, 0], label='Series 1', color='r')
ax.bar(df['x'], y_percent.iloc[:, 1], bottom=y_percent.iloc[:, 0], label='Series 2', color='g')
ax.bar(df['x'], y_percent.iloc[:, 2], bottom=y_percent.iloc[:, :2].sum(axis=1), label='Series 3', color='b')

# Display the plot
plt.show() Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on or (@Luca_DataTeam). You can also catch glimpses of my personal life on , Happy exploring!👋 LinkedIn X Instagram

Four Types of Bar Charts in Python - Based on Tabular Data

Simple bar chart based on an array in Python import matplotlib.pyplot as plt
import numpy as np

x = np.array(['A', 'B', 'C', 'D', 'E'])
y = np.array([50, 30, 70, 80, 60])

plt.bar(x, y, align='center', width=0.5, color='b', label='data')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.title('Bar chart')
plt.legend()
plt.show() Stacked bar chart based on arrays in Python import matplotlib.pyplot as plt
import numpy as np
x = np.array(['A', 'B', 'C', 'D', 'E'])
y1 = np.array([50, 30, 70, 80, 60])
y2 = np.array([20, 40, 10, 50, 30])

plt.bar(x, y1, align='center', width=0.5, color='b', label='Series 1')
plt.bar(x, y2, bottom=y1, align='center', width=0.5, color='g', label='Series 2')
plt.xlabel('X axis')
plt.ylabel('Y axis')
plt.title('Stacked Bar Chart')
plt.legend()
plt.show() Grouped bar chart based on arrays in Python import matplotlib.pyplot as plt
import numpy as np

# Prepare the data
N = 5
men_means = (20, 35, 30, 35, 27)
women_means = (25, 32, 34, 20, 25)
ind = np.arange(N)  # x-axis position
width = 0.35  # width of each bar

# Plot the bar chart
fig, ax = plt.subplots()
rects1 = ax.bar(ind, men_means, width, color='r')
rects2 = ax.bar(ind + width, women_means, width, color='y')

# Add labels, legend, and axis labels
ax.set_xticks(ind + width / 2)
ax.set_xticklabels(('G1', 'G2', 'G3', 'G4', 'G5'))
ax.legend((rects1[0], rects2[0]), ('Men', 'Women'))
ax.set_xlabel('Groups')
ax.set_ylabel('Scores')

# Display the plot
plt.show() Percent stacked bar chart based on arrays in Python import matplotlib.pyplot as plt
import numpy as np

# Prepare the data
x = ['Group 1', 'Group 2', 'Group 3', 'Group 4', 'Group 5']
y = np.array([[10, 20, 30],
              [20, 25, 30],
              [15, 30, 25],
              [25, 15, 20],
              [30, 20, 10]])

# calculate percentage
y_percent = y / np.sum(y, axis=1, keepdims=True) * 100

# Plot the chart
fig, ax = plt.subplots()
ax.bar(x, y_percent[:, 0], label='Series 1', color='r')
ax.bar(x, y_percent[:, 1], bottom=y_percent[:, 0], label='Series 2', color='g')
ax.bar(x, y_percent[:, 2], bottom=y_percent[:, 0] + y_percent[:, 1], label='Series 3', color='b')

# Display the plot
plt.show() Thank you for taking the time to explore data-related insights with me. I appreciate your engagement. If you find this information helpful, I invite you to follow me or connect with me on or (@Luca_DataTeam). You can also catch glimpses of my personal life on , Happy exploring!👋 LinkedIn X Instagram Also published . here

Four Types of Array Data-Based Bar Charts in Python

As , we are always striving for high performance and efficiency in our code. Whether it’s optimizing algorithms or fine-tuning data structures, every decision we make can have a significant impact on the overall performance of our applications. One powerful way that can help us accurately measure the performance of our code is a process called benchmarking and we’ll look at how to use BenchmarkDotNet with our C# code. software engineers In this article, we’ll explore the ins and outs of using BenchmarkDotNet to benchmark C# code efficiently. We’ll be starting with the setup and I’ll guide you through examples of how to write benchmarks and run them as well. By the end, you’ll be able to write and run benchmarks on your C# code using BenchmarkDotNet effectively. Let’s jump into it! 1 – Installing and Setting Up BenchmarkDotNet The first step is to in your project. You can do this by opening the NuGet Package Manager in Visual Studio and searching for “BenchmarkDotNet.” Select the latest version and click on the Install button to add it to your project. There are no other external dependencies or anything fancy that you need to do to get going. install the BenchmarkDotNet package As you’ll see in the following sections, it’s purely code configuration after the NuGet package is installed! It’s worth mentioning that BenchmarkDotNet automatically performs optimizations during benchmarking C# code, such as JIT warm-up and running benchmarks in a random order, to provide accurate and unbiased results. But this all happens without you having to do anything special. Keep in mind, that just like with writing tests, you’ll very likely want to have your benchmark code in a dedicated project. This will allow you to release your core code separately from your benchmarks. There are probably not a lot of great reasons to deploy your benchmark code with your service or ship your benchmark code to your customers. 2 – Getting Started With Benchmark Methods in BenchmarkDotNet When it comes to writing benchmark methods using the BenchmarkDotNet framework, there are a few things we need to configure properly. In this section, I’ll guide you on how to write effective benchmark methods that accurately measure the performance of your C# code. This video on getting started with BenchmarkDotNet is a helpful guide as well: https://youtu.be/Wa3sdKGp3wE?embedable=true Structure Your Benchmark Code It’s important to structure your benchmark code properly to ensure accurate and efficient benchmarks. Follow these guidelines: : Start by creating a dedicated class for your benchmarks. This keeps your benchmark code organized and separate from the rest of your application code. Create a separate class for benchmarks : Select the appropriate type of benchmark job you’d like to run by marking your benchmark class with one of the following attributes , , , or . Apply the correct [XXXRunJob] attribute [ShortRunJob] [MediumRunJob] [LongRunJob] [VeryLongRunJob] attribute: To enable memory measurements during the benchmark, apply the attribute to your benchmark class. This attribute allows you to gather memory-related information along with execution time. If you’re strictly concerned about runtime and not memory, you can omit this. Apply the [MemoryDiagnoser] [MemoryDiagnoser] Note that your class cannot be sealed. I’d recommend just sticking to a standard definition with the appropriate attributes from above. You can have your benchmark class inherit from something else though, so if you find there’s a benefit to using some inheritance here for reusability, that might be a viable option. public class Writing Benchmark Methods Benchmark methods are where you define the code that you want to measure. Here are some tips for writing benchmark methods using BenchmarkDotNet: Apply the attribute: Each benchmark method needs the attribute. This attribute tells BenchmarkDotNet that this method should be treated as a benchmark. [Benchmark] [Benchmark] Avoid setup costs in benchmark methods: Benchmark methods should focus on measuring the performance of the code itself, not the cost of initializing your benchmark scenario. Avoid allocations and overuse of memory: Benchmark methods should not be concerned with the overhead caused by memory allocations. Minimize allocations and reduce memory usage within your benchmark methods to get accurate performance measurements. Note that BenchmarkDotNet handles all of the warmup for you – You don’t need to go out of your way to manually code in doing iterations ahead of time to get things to a steady state before benchmarking C# code. Example Benchmark Method: Here’s an example of a benchmark method in BenchmarkDotNet: [Benchmark]
public void SimpleMethodBenchmark()
{
    for (int i = 0; i < 1000; i++)
    {
        // Execute the code to be measured
        MyClass.SimpleMethod();
    }
} In this example, the attribute is applied to the method, indicating that it should be treated as a benchmark. Suppose we were using an instance method instead of a static method as illustrated. In that case, we’d want to instantiate the class OUTSIDE of the benchmark method — especially if we need to create, configure, and pass in dependencies. Minimize (read: eliminate) the amount of work done in the method that isn’t what you are trying to benchmark. [Benchmark] SimpleMethodBenchmark Remember, if you’re interested in memory in addition to the runtime characteristics, make sure to apply the attribute to the benchmark class — not the method that is the benchmark. [MemoryDiagnoser] 3 – Running Benchmarks with BenchmarkDotNet When it comes to running benchmarks using BenchmarkDotNet in C#, there are a few important considerations to keep in mind. In this section, I’ll explain how to run benchmarks, discuss different scenarios and options, and provide code examples to help you get started. You can follow along with this video on how to run your BenchmarkDotNet benchmarks as well: https://youtu.be/Hqeq9ycqteQ?embedable=true Running Benchmarks With BenchmarkRunner The BenchmarkRunner class provides a very simple mechanism for running all of the Benchmarks that you provide it from a type, list of types, or an assembly. The benefit of this is in the simplicity as you can just run the executable and it will go immediately run all of the benchmarks that you’ve configured the code to run. You can or below: check out some example code on GitHub using BenchmarkDotNet.Running;

var assembly = typeof(Benchmarking.BenchmarkDotNet.BenchmarkBaseClass.Benchmarks).Assembly;

BenchmarkRunner.Run(
    assembly,
    args: args); In the code above, we are simply specifying an assembly for one of our benchmarks. However, you could use or find other ways to list the types you’re interested in. Assembly.GetExecutingAssembly Running Benchmarks With BenchmarkSwitcher The BenchmarkSwitcher class is very similar – but the behavior is different in that you can filter which benchmarks you’d like to run. There are some slight API differences in that the BenchmarkRunner allows you to specify a collection of assemblies where the BenchmarkRunner (at the time of writing) does not. Here’s a code example, or you can : check out the GitHub page using BenchmarkDotNet.Running;

var assembly = typeof(Benchmarking.BenchmarkDotNet.BenchmarkBaseClass.Benchmarks).Assembly;


BenchmarkSwitcher
    // used to load all benchmarks from an assembly
    .FromAssembly(assembly)
    // OR... if there are multiple assemblies,
    // you can use this instead
    //.FromAssemblies
    // OR... if you'd rather specify the benchmark
    // types directly, you can use this
    ///.FromTypes(new[]
    ///{
    ///    typeof(MyBenchmark1),
    ///    typeof(MyBenchmark2),
    ///})
    .Run(args); As you will note in the code comments above, there are several ways that we can call the BenchmarkSwitcher. The primary difference between these two methods is that the switcher will allow you to provide user input or filter on the commandline. 4 – Customizing Benchmark Execution BenchmarkDotNet provides various options to customize the execution of your benchmarks, allowing you to fine-tune the benchmarking process according to your needs. Two important options to consider are the iteration count and warm-up iterations. Configuring Parameters for Benchmarks If we want to have variety in our benchmark runs, we can use the attribute on a public field. This is akin to using the xUnit Theory for parameterized tests, if you’re familiar with that. For each field you have marked with this attribute, you’ll essentially be building a matrix of benchmark scenarios to go run. [Params] Let’s check out some example code: [MemoryDiagnoser]
[ShortRunJob]
public class OurBenchmarks
{
    List<int>? _list;

    [Params(1_000, 10_000, 100_000, 1_000_000)]
    public int ListSize;

    [GlobalSetup]
    public void Setup()
    {
        _list = new List<int>();
        for (int i = 0; i < ListSize; i++)
        {
            _list.Add(i);
        }
    }

    [Benchmark]
    public void OurBenchmark()
    {
        _list!.Sort();
    }
} In the code above, we have a field which is marked with . This means that in our method, we’re able to get a new value for each variation of the benchmarking matrix we want to run. In this case, since there’s only one parameter, there will only be a benchmark for each value of ListSize — so 4 different benchmarks based on the 4 different values specified. ListSize [Params] [GlobalSetup] Adjusting Per Benchmark Iteration Count BenchmarkDotNet allows you to control the number of method. By default, each benchmark is executed a reasonable number of times to obtain reliable measurements. However, you can adjust the iteration count by applying the attribute to individual benchmark methods, specifying the desired number of iterations. iterations for each benchmark [IterationCount] [Benchmark]
[IterationCount(10)] // Custom iteration count
public void MyBenchmarkMethod()
{
    // Benchmark code here
} I should note that in practice, I have not personally had to configure the iteration count manually. Custom Per Benchmark Warm-up Iterations Warm-up iterations are executed before the actual benchmark starts, allowing the JIT compiler and CPU caches to warm up. This helps eliminate any performance inconsistencies caused by the initial compilation of the benchmark method. You can customize the number of warm-up iterations using the attribute. [WarmupCount] [Benchmark]
[WarmupCount(5)] // Custom warm-up count
public void MyBenchmarkMethod()
{
    // Benchmark code here
} Like the iteration count, I have also not had an issue with the default warmup. I’d advise that you leave these as defaults unless you know what you’re doing to tune these accordingly. 5: Analyzing and Interpreting Benchmark Results from BenchmarkDotNet Benchmarking is an important part of the software development process when it comes to optimizing performance. After running benchmarks using BenchmarkDotNet, it’s important to be able to accurately analyze and interpret the results. In this section, I’ll guide you through the process of analyzing benchmark results and identifying potential performance improvements. Establishing a Baseline Benchmark in BenchmarkDotNet When analyzing benchmark results, several key metrics can provide valuable insights into the performance of your code. But what can be challenging is understanding what you’re trying to compare against. If you simply have two implementations you are trying to compare against, it may not feel that challenging. However, when you’re comparing many you likely want to establish a baseline to see your improvements (or regressions). Here’s how we can make a benchmark method as a “baseline”: [Benchmark(Baseline = true)]
public void Baseline()
{
    // Code under benchmark
} Interpreting Benchmark Results Once you have the benchmark results and understand the key metrics, it’s important to interpret the findings to identify potential performance improvements. Here are a few examples of how to interpret the benchmark results: Identifying Bottlenecks: Look for outliers or significantly higher execution times in certain benchmarks. This could indicate potential bottlenecks in your code that need to be optimized. Comparing Performance: Compare the mean or median execution times of different benchmark methods or different versions of your code. This can help you identify which approach or version is more efficient. Spotting Variability: Pay attention to the standard deviation and percentiles to identify any significant variability in the benchmark results. This can help you identify areas where performance optimizations could make a difference. I find that I am spending most of my time looking at the median/mean to see what stands out as faster and slower. If you need to dive deeper into the statistical analysis and you just need a primer, I have found even . Wikipedia provided a reasonable starting point 6: Optimizing C# Code with BenchmarkDotNet As software engineers, we constantly strive to write code that is not only functional but also performs efficiently. BenchmarkDotNet is a powerful tool that helps us measure and compare the performance of our code. By analyzing the results provided by BenchmarkDotNet, we can identify areas where our code may be underperforming and optimize it to achieve better results. In this section, I’ll share some techniques for optimizing C# code based on the results we’d gather from running our benchmarks. You can check out this video on measuring and tuning iterator performance for a practical example: https://youtu.be/G2-d7kZFlRA?embedable=true Identifying Performance Bottlenecks One of the first steps in optimizing C# code is identifying the performance bottlenecks. BenchmarkDotNet allows us to measure the execution time of our code and compare different implementations. By analyzing the benchmark results, we can pinpoint the areas that are taking up the most time. Let’s consider an example where we have a loop that performs a computation on a large array. We can use BenchmarkDotNet to measure the execution time of different implementations of this loop and identify any potential bottlenecks. [ShortRunJob]
public class ArrayComputation
{
    private readonly int[] array = new int[1000000];

    [GlobalSetup]
    public void Setup()
    {
        // TODO: decide how you want to fill the array :)
    }

    [Benchmark]
    public void LoopWithMultipleOperations()
    {
        for (int i = 0; i < array.Length; i++)
        {
            array[i] += 1;
            array[i] *= 2;
            array[i] -= 1;
        }
    }

    [Benchmark]
    public void LoopWithSingleOperation()
    {
        for (int i = 0; i < array.Length; i++)
        {
            array[i] = (array[i] + 1) * 2 - 1;
        }
    }
} In this example, we have two benchmark methods and . The first method performs multiple operations on each element of the array, while the second method combines the operations into a single computation. By comparing the execution times of these two methods using BenchmarkDotNet, we can determine which implementation is more efficient. LoopWithMultipleOperations LoopWithSingleOperation Recall from the earlier sections to we could parameterize this for different sizes! Sometimes this is necessary to see if we have different behaviors under different scenarios, so it’s worth exploring beyond just the surface. Optimizing Loops and Reducing Memory Allocations Loops are often an area where we can optimize our code for better performance. Inefficient loops can result in unnecessary memory allocations or redundant computations. BenchmarkDotNet can help us identify such issues and guide us in optimizing our code. Consider the following example where we have a loop that concatenates strings, and we’re making sure to use a as well: [MemoryDiagnoser] [MemoryDiagnoser]
[ShortRunJob]
public class StringConcatenation
{
    private readonly string[] strings = new string[1000];

    [GlobalSetup]
    public void Setup()
    {
        // TODO: decide how you want to fill the array :)
    }

    [Benchmark]
    public string ConcatenateStrings()
    {
        string result = "";
        for (int i = 0; i < strings.Length; i++)
        {
            result += strings[i];
        }

        return result;
    }

    [Benchmark]
    public string StringBuilderConcatenation()
    {
        StringBuilder stringBuilder = new StringBuilder();
        for (int i = 0; i < strings.Length; i++)
        {
            stringBuilder.Append(strings[i]);
        }

        return stringBuilder.ToString();
    }
} In this example, we have two benchmark methods: and . The first method uses string concatenation inside a loop, which can result in frequent memory allocations and poor performance. The second method uses a to efficiently concatenate the strings. By comparing the execution times of these two methods using BenchmarkDotNet, we can observe the performance difference and validate the effectiveness of using a for string concatenation. ConcatenateStrings StringBuilderConcatenation StringBuilder StringBuilder Now You Know How to Use BenchmarkDotNet! BenchmarkDotNet is a valuable tool for accurately and efficiently benchmarking C# code. Throughout this article, we explored tips for using BenchmarkDotNet effectively. By leveraging these, you can accurately measure and optimize the performance of your C# code. Improved performance can lead to more efficient applications, better user experiences, and overall enhanced software quality! Remember, benchmarking is an iterative process, and there are other resources and tools available that can further assist you in optimizing your C# code. Consider exploring profiling tools, performance counters, and other performance analysis techniques to gain deeper insights into your application’s performance. If you found this useful and you’re looking for more learning opportunities, consider and check out my ! subscribing to my free weekly software engineering newsletter free videos on YouTube Also published . here

G2

g2.com

-- employees

Since n.d.

COMPANY RANKING

G2

EVERGREEN INDEX #5071

Representing this company? Click here to claim and customize this page!

G2 WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

G2