MyBea

mybea

If building products is hard, positioning your product is harder. No matter what you build and sell, how you position your product dictates what you do. How you prioritize, marketing campaigns, sales strategy, it all changes based on how your product is positioned. So where do you start? How do you position your product? Step 1: Understand why Your Customers use Your Product to discover if you’ve hit product/market fit is a great way to understand your customers. If you dig deep enough, you’ll notice it isn’t just a framework to see how many people love your product, but also to understand what they’d do if you did not exist, who your competitors are, and what value they derive from you. Sean Ellis’ survey Put simply, you should ask your customers these three questions to understand more about them: If {Your Product Name} did not exist tomorrow, will you be unhappy, somewhat unhappy, or not disappointed? Why? What primary benefit do you receive from {Your Product Name}? What product will you start using as an alternative? The second survey question is my favourite, especially when it enables you to map the benefit directly to a feature. It tells you the value your customers get from your product and which aspect of your product is key to them. It means you can then get your team to fix broken flows around it and double down to ensure more users see its value. Step 2: Identify the Market You’re in and the Persona You’re Going After You probably already had an idea of your market as you built the product. If you are building a CRM tool, you’re playing in the CRM space. Obvious and easy. But it doesn’t end there. You’ll still have to answer questions such as whether the person you sell to is a manager or somebody involved in daily execution. Will you be selling to salespeople at tech companies or to retail businesses? The data you get from your first step should ideally help you determine which market you’re in. You should start to see clusters of users with similar profiles, who all say they’d be disappointed without your product, and describe a benefit around a common theme. Step 3: Determine the Market’s Maturity The maturity of your market plays a huge role in determining your product’s messaging. In a relatively new market, you have to first establish the problem before talking about what you offer. In an established market, simply stating you are in the specific market will be sufficient, but you’ll have to convince people why you exist. Not with features, but with benefits. For companies in a hyper-competitive market, like CRM, product features and benefits usually match those of competitors. Differentiation becomes all the more important when products and services are indistinguishable — this is a process that begins with a story. My favourite example is Unilever personal care subsidiary, . How do you differentiate a soap’s messaging? What feature could it have that other soaps don’t have? Or can’t copy from them? Dove While other soaps in the market say their soap would make people’s skin fresh and clean, Dove has taken a different approach. It runs to reinforce its female empowerment story. #MyBeautyMySay campaigns Step 4: Determine People’s State of Mind A lot goes through someone’s mind when deciding if they should use your product. This can be summarized as four forces: Push Pull Anxiety Habit When people switch from their current tool to yours, they are usually unhappy with their current way of working (push) and/or are attracted by what you have to offer (pull). Before people make the switch, you must address their concerns (anxiety), get them to trust you, and ensure they don’t have to go through a tedious process like learning a new flow to switch (habit). For most products, it is usually a combination of push and pull that makes people consider your product. And once that is established, a combination of their anxiety levels and habits will determine if they will make the switch. Image credit: Jobs-to-be-Done forces diagram by Margaret Wilkins Step 5: Tying it Together Using all the above data points, you should now pick a market frame of reference that makes your value obvious to the segments who care the most about that value. This is harder than you might think. In the context of this step, a “market” needs to be something that already exists in the minds of your customers and triggers a set of expectations: How your competitors can’t do certain things. How the lack of these capabilities bring pain to your users Features you have How these features give your customers the benefit Positioning yourself as something that already exists in your customers’ minds will help you focus on communicating why they should choose you – the differentiator – and not the features. The tone and the angle you use to position your product will depend on the market and the buyer’s state of mind you’ve surmised from steps 3 and 4. A great way to bring it all together in words is to use the Before and After grid below. By using all the data points you’ve already collected, you can put into words how each customer segment thinks and feels before they use your product and after they use your product. To explain the above table: – This should talk about their biggest pain point. For a manager, it could be a disorganized team. What do they have? – It is easy to simply stick to surface-level feelings like frustrated or unhappy. But when you dig deeper, and unearth feelings like being overwhelmed and insecure, you’ll hit a pot of gold that will help your positioning and messaging. How do they feel? – The average day for a manager who has a disorganized team is constantly to coach the team. What is their average day like? – Your product could help a sales rep hit their targets consistently and get promoted to a managerial post. What is their status? When our early prospective customers started to ask how we were different from the others in the market, we knew it wasn’t enough to just tell them we were building a faster, easier project management tool. We took this approach at Zepel , a JIRA alternative we’re building. So we took a step back, looked into our data, and noticed the current tools catered to simple task and issue tracking when in reality, teams were trying to go beyond it. Teams didn’t want to just jot down a list of user stories for their developers to work on, they wanted to be able to plan and conceptualize an entire feature before handing it over. They didn’t want to get different sets of updates from developers, designers, and their QA team on each individual tasks. They wanted to know the progress of an entire feature across every discipline. And when they were on a deadline to not just ship the feature, but a quality one at that, they didn’t want to be overwhelmed with all the task level updates. They wanted to know how far away they were from shipping the feature and see if they needed to course-correct. Once we had boiled this down, it helped us realize we weren’t just building a faster, easier to use agile project management tool. We were building a project management tool to go beyond simple issue tracking, one that could bring members from every discipline together and adapt to the way modern software product teams really work. That way, everyone would get to do what they do best without having to babysit the tool. Of course, like everything in building products, your positioning will go through iterations, change, and evolve. But once you get it right, you can pass every product, marketing, and sales question through a simple filter by asking “by doing this, are we strengthening our positioning or are we watering it down?”. Conclusion Customers seeking new products don’t have a single-minded focus: brands need to stand out clearly and connect with their audience. Doing that requires companies to go beyond just stating features and benefits. Focusing on the market and its maturity will let you weave a story that stands out, focus on the customer, and differentiate yourself. Take Slack vs HipChat, for example. In a popular (and a must-read) , CEO of Slack, he says: “What we are selling is not the software product — the set of all the features, in their specific implementation — because there are just not many buyers for this software product.” He goes on to add: “That’s why what we’re selling is organizational transformation. The software just happens to be the part we’re able to build and ship.” article by Stewart Butterfield Had Slack positioned itself to go after the same enterprise market as HipChat, it would most certainly look and feel very different. And we certainly wouldn’t have the fun, friendly chat tool that many of us love and use today.

Five Steps to Positioning Your Product

Rethinking our commit messages structure. is the most used for projects based mainly on text files, like source code etc. Git Version Control System If you are working in a company, in a team or also alone, probably you are using also an issue/project tracker like JIRA or the ones included in GitHub, GitLab and Bitbucket. The advantage of those pieces of software is that we can create “issues” or “tickets”, each of those tracking of a single feature or bug correction in our software. They work by creating and assigning an ID to the newly created ticket — that can be numeric or include a brief project identifier like — in the way you can keep each one easily referenceable in chats, groups, , etc. development ALX-1231 commits Commits, commits, commits If we have used Git at least one time, we would know that the standard commit message structure is: Commit summary description; corrected my horrible bug Long description (sometimes called "body"), with things like:* bulleted list of changes;* other change;* chirp chirp Notice the new line between the summary and the body: Git doesn’t enforce it, but we to insert it if we want to specify a body, else the commit will not be parsed in the correct way. have Many teams have a default way to reference tickets created with tracking software, putting the issue ID inside the commit message itself. The standard I saw more frequently is something like this: ALX-21313 Done that fancy change; now we have cats in the UI Seems good, probably you are using it in your dev workflow. But I want to talk about why I think this structure is not the best one to use. 1. Using the issue ID as first-class citizen into our commit message is not the best thing to do. We have Git, and then we have a separate system that manages issues. One day in the future the latter could stop working, be abandoned, its database could be deleted as a mistake, or everything else. In that moment, we will realise that our Git messages will have a consistent part that has no more meaning. Issue trackers are not part of the Git repo. 2. The issue ID is wasting precious space that instead could be used to explain what we’ve done in that commit. Commit summaries should have less than 50 characters. Appending 6/7 characters for the issue ID means that we’ll have 6/7 — but maybe more — less characters to use for describing what changes were made. Yes: we could write the full text into the description, but probably we could have used those 7 chars for fitting those in the summary write the issue ID in the description (spoiler to my solution at the end of the article). and then Apart from this, in my experience I found that developers that uses IDs before the “real” commit message, tend to be lazy about what to write in the summary, because they are psychologically prone to the fact that who’s going to read the message, will check the ticket itself for more details. This will take time from him; time otherwise used for being productive. This without quoting the possibility that the issue manager itself could be not accessible temporarily or indefinitely. 3. The linked issue’s nature and its state after the commit is not clear. An issue can have different types. It can be a bug, a new feature, etc. If we just put its ID in front of the message, who will check our project’s logs won’t know if that commit will fix, close or just reference that particular ticket. For more info, again, he has to go to the issue manager, breaking its workflow. 4. What about many issues? And no issues at all? Let’s say that our commit fixes three tickets, because those were very similar (sometimes is possible that QAs create different issues, without knowing that they are caused by the same bug in the code). We’ll have something like ALX-12323 ALX-12324 ALX-12325 Something fixed finally Isn’t that ugly? And what about the opposite? When we are making a subtle change like correcting a typo in a comment. We can’t create a ticket just for correcting a word in an insignificant comment (we could but I think it feels quite paranoid). So we’ll have a commit message without an initial commit, resulting quite incoherent respect to the other commit messages. The approach I suggest If I convinced you with the previous points that the most used format is not so useful and perfect, now I’m going to explain my favourite approach to Git messages. The first thing we are going to do is to . Don’t look at the issue/ticket! Just look at your changes and describe briefly what we changed in overall. explain the code changes in a summarily way Renamed MyUglyTweet to MyBeautifulTweet If we have made many changes in this commit, describe the main purpose of those changes, and then we’ll continue to explain it in the (if needed): commit body Added little birbs to the homescreen * Updated BIRDS_NUMBER constant;* created the interface Chirp and implemented in ChirpImpl; “Ok Alex, but when should we put our issue IDs?”Once we have finished to summarize every block of changes we made, let’s decide where to put our ticket identifiers. If our commit contains changes regarding just one ticket, I follow this path: if there’s enough space in the summary, I append the issue preceded by a verb that will describe how that’s related. For example: Added little birbs to the homescreen; closes ALX-1434 We can use closes, closed, close, as soon that verb identifies what we’ve done on that ticket. I use close for feature tickets, but in the case of a bug ticket, I usually use “fixes” or “fixed”. For these verbs, or , we can check here because specifying those in the commit helps some issue trackers (like the GitHub one) to close automatically our tickets when a feature branch is merged with our main development branch. keywords https://help.github.com/articles/closing-issues-using-keywords/, If there’s no space left in the summary, we can put the ticket on the description: Added little birbs to the homescreen, bla bla bla boring Closes ALX-1434. Or, if we have a list of things changed (but our commit closes only one ticket), we can put the issue in a separate list item: Added little birbs to the homescreen, bla bla bla boring * Created new classes;* injected cream in the blender;* closes ALX-1434 In case we have more issues closed by our commit, we’ll try to have one element of the list for each issue closed: Refactored code bla bla bla bla here's no space to write anything * Extracted interface from the Qwack class (closes ALX-1323);* cut wings to Para.kt 🐦 (fixes ALX-1324);* this other change doesn't close anything 😔 I think this approach is quite simple but very effective for including our tickets in the commits without sacrificing the importance to write a commit message that can be read without the issue tracker opened on our browser (and with a proper integration, we can leave our automations to move tickets as we do certain actions, but I’ll leave this to another article). If you enjoyed reading this article, feel free to click the 👏 button how many times you want! Extra chapter: do you know that you can use emoji in your commit messages? 😁 Maybe you’ve noticed that I used and in my last example commit message. That’s a word enclosed by two colons (the punctuation symbol, not the intestine part…) that will be converted from many Git services to real emoji! GitHub, Bitbucket and GitLab all have support for this feature. :bird: :pensive: All the emoji with relative code are on websites like . https://emoji.muan.co/ Git commits don’t need to be boring, but remember: be responsible and use your emoji in your description, or in your summary only if you are sure that you have enough space, and more important , because who’s reading that commit message could be using the terminal! 😉 really don’t use emoji for explaining stuff Sorry for the long post, here’s a pic of a . Photo by via Pixabay. birb cornelinux

On Git commit messages and issue trackers

How to Master .NET 8 Web API: From Setup to Security - The Best 50 Tips

কিভাবে .NET 8 ওয়েব এপিআই আয়ত্ত করবেন: সেটআপ থেকে নিরাপত্তা - সেরা 50 টি টিপস

.NET 8 Web API meistern: Von der Einrichtung bis zur Sicherheit – Die 50 besten Tipps

Cómo dominar la API web .NET 8: de la configuración a la seguridad: los 50 mejores consejos

Comment maîtriser l'API Web .NET 8 : de la configuration à la sécurité - Les 50 meilleurs conseils

.NET 8 वेब एपीआई में महारत कैसे हासिल करें: सेटअप से सुरक्षा तक - सर्वोत्तम 50 युक्तियाँ

.NET 8 Web API をマスターする方法: セットアップからセキュリティまで - ベスト 50 のヒント

.NET 8 Web API를 마스터하는 방법: 설정부터 보안까지 - 최고의 50가지 팁

Como dominar a API da Web .NET 8: da configuração à segurança - as 50 melhores dicas

Как освоить веб-API .NET 8: от настройки до безопасности — 50 лучших советов

.NET 8 Web API'sinde Uzmanlaşma: Kurulumdan Güvenliğe - En İyi 50 İpucu

Cách làm chủ API Web .NET 8: Từ thiết lập đến bảo mật - 50 mẹo hay nhất

如何掌握 .NET 8 Web API：从设置到安全 - 50 个最佳技巧

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

6 Simple Performance-Boosting Tips to Get Started With BenchmarkDotNet

Debugging effectively requires a nuanced approach, similar to using tongs that tightly grip the problem from both sides. While low-level tools have their place in system-level service debugging, today's focus shifts towards a more sophisticated segment of the development stack: advanced management tools. Understanding these tools is crucial for developers, as it bridges the gap between code creation and operational deployment, enhancing both efficiency and effectiveness in managing applications across extensive infrastructures. https://www.youtube.com/watch?v=rQjHAMM3XfY&embedable=true As a side note, if you like the content of this and the other posts in this series, check out my that covers his subject. If you have friends who are learning to code, I'd appreciate a reference to my If you want to get back to Java after a while, check out my Debugging book t Java Basics book. Java 8 to 21 book . The Need for Advanced Management Tools in Development Development and DevOps teams utilize an array of tools, often perceived as complex or alien by developers. These tools, designed for scalability, enable the management of thousands of servers simultaneously. Such capabilities, although not always necessary for smaller scales, offer significant advantages in application management. Advanced management tools facilitate the navigation and control over multiple machines, making them indispensable for developers seeking to optimize application performance and reliability. Introduction to JMX (Java Management Extensions) One of the pivotal standards in application management is Java Management Extensions (JMX), which Java introduced to simplify the interaction with and management of applications. JMX allows both applications and the Java Development Kit (JDK) itself to expose critical information and functionalities, enabling external tools to manipulate these elements dynamically. Although activating JMX falls outside this discussion, its significance cannot be overstated, with ample resources available for those interested in its implementation. Setting up JMX JMX isn't enabled by default; to enable it, we need the following steps: : To enable JMX on a Java application, you must adjust the Java Virtual Machine (JVM) startup parameters. This involves adding specific flags to your application's startup command. The essential flags for enabling JMX are: Modify the JVM Startup Parameters : This flag activates the JMX remote management and monitoring. -Dcom.sun.management.jmxremote : Replace with a specific port number where the JMX remote connection will listen. -Dcom.sun.management.jmxremote.port=<PORT> <PORT> : This flag disables SSL for JMX connections. For development environments, SSL might be disabled for simplicity, but for production environments, consider enabling SSL for security. -Dcom.sun.management.jmxremote.ssl=false : This flag disables authentication. Similar to SSL, authentication may be disabled in development but should be enabled in production to ensure secure access. -Dcom.sun.management.jmxremote.authenticate=false : With the JVM parameters set, restart your application. This will apply the new startup parameters, activating JMX. Restart Your Application : After restarting your application, you can verify that JMX is enabled by connecting to it using a JMX client such as JConsole, VisualVM, or a custom management application. Use the port number specified in the startup parameters to establish the connection. Verify JMX Connectivity JMX Security Considerations While enabling JMX provides powerful management capabilities, it's crucial to consider security implications, especially when JMX is exposed over a network. When deploying applications in production, always enable SSL and authentication to protect against unauthorized access. Additionally, consider firewall rules and network policies to restrict JMX access to trusted clients. Understanding MBeans Central to JMX are Management Beans (MBeans), which serve as the control points within an application. These beans enable developers to publish specific functionalities for runtime monitoring and configuration. The ability to export application metrics to dashboards through MBeans is particularly valuable, facilitating real-time decision-making based on accurate, up-to-date information. Furthermore, operations such as user management can be exposed through MBeans, enhancing administrative capabilities. Spring and Management Beans Spring Framework's Actuator module exemplifies the integration of management capabilities within development, offering extensive metrics and operational details. This integration propels applications to "production-ready" status, allowing developers to monitor and manage applications with unprecedented depth and efficiency. Tooling for JMX Management While JMX can be accessed through various web interfaces and administrative tools, command-line tooling offers a direct, efficient method for interacting with JMX-enabled applications on production servers. Tools like JMXTerm complement visual tools by providing a streamlined interface for rapid insights, especially in environments unfamiliar to the developer. Getting Started with JMXTerm JMXTerm is a powerful utility for managing JMX without the need for graphical visualization, ideal for quick diagnostics or high-level server insights. After enabling JMX on the JVM and setting up the necessary configurations, developers can connect to servers, explore different JMX domains, and manipulate MBeans directly from the command line. We can accomplish all of the following via visual tools and sometimes using a web interface. Normally, that's the approach I use. However, as a learning tool I think JMXTerm is fantastic since it exposes things in a way that's consistent and verbose. If we can understand JMXTerm, the GUI version would be a walk in the park... We can launch JMXTerm using the command line. In my case, I used the following command: java -jar ~/Downloads/jmxterm-1.0.2-uber.jar --url localhost:30002 Once the connection is made, we can issue commands to JMX and retrieve information about the JVM or the application e.g., I can list the domains that you can think of as similar to "packages" or "modules," a way to organize the various beans: $>domains
#following domains are available
JMImplementation
com.sun.management
java.lang
java.nio
java.util.logging
javax.cache
jdk.management.jfr I can select a specific domain and thus perform future operations within said domain: $>domain java.util.logging
#domain is set to java.util.logging Once inside the domain, I can select a specific bean and perform operations on it. For this I need to first list the beans in the domain, in this case there's only the logging bean. I can then select that bean using the command: bean $>beans
#domain = java.util.logging:
java.util.logging:type=Logging
$>bean java.util.logging:type=Logging
#bean is set to java.util.logging:type=Logging I can perform many operations on beans. Perhaps the most useful is the command, which lets me query a bean. Notice that a bean can have attributes, think of them like object fields and operations which you can think of as methods. There are also notifications which you can think of as events: info $>info
#mbean = java.util.logging:type=Logging
#class name = sun.management.ManagementFactoryHelper$PlatformLoggingImpl
# attributes
  %0   - LoggerNames ([Ljava.lang.String;, r)
  %1   - ObjectName (javax.management.ObjectName, r)
# operations
  %0   - java.lang.String getLoggerLevel(java.lang.String p0)
  %1   - java.lang.String getParentLoggerName(java.lang.String p0)
  %2   - void setLoggerLevel(java.lang.String p0,java.lang.String p1)
#there's no notifications I can run operations and pass various commands e.g., I can get the logger level, set it, and then check that the logger level was indeed updated: $>run getLoggerLevel "org.apache.tomcat.websocket.WsWebSocketContainer"
#calling operation getLoggerLevel of mbean java.util.logging:type=Logging with params [org.apache.tomcat.websocket.WsWebSocketContainer]
#operation returns:
$>run setLoggerLevel org.apache.tomcat.websocket.WsWebSocketContainer INFO
#calling operation setLoggerLevel of mbean java.util.logging:type=Logging with params [org.apache.tomcat.websocket.WsWebSocketContainer, INFO]
#operation returns: 
null
$>run getLoggerLevel "org.apache.tomcat.websocket.WsWebSocketContainer"
#calling operation getLoggerLevel of mbean java.util.logging:type=Logging with params [org.apache.tomcat.websocket.WsWebSocketContainer]
#operation returns: 
INFO This is just the tip of the iceberg. We can get many things, such as spring settings, internal VM information, etc. In this example, I can query VM information directly from the console: $>domain com.sun.management
#domain is set to com.sun.management
$>beans
#domain = com.sun.management:
com.sun.management:type=DiagnosticCommand
com.sun.management:type=HotSpotDiagnostic
$>bean com.sun.management:type=HotSpotDiagnostic
#bean is set to com.sun.management:type=HotSpotDiagnostic
$>info
#mbean = com.sun.management:type=HotSpotDiagnostic
#class name = com.sun.management.internal.HotSpotDiagnostic
# attributes
  %0   - DiagnosticOptions ([Ljavax.management.openmbean.CompositeData;, r)
  %1   - ObjectName (javax.management.ObjectName, r)
# operations
  %0   - void dumpHeap(java.lang.String p0,boolean p1)
  %1   - javax.management.openmbean.CompositeData getVMOption(java.lang.String p0)
  %2   - void setVMOption(java.lang.String p0,java.lang.String p1)
#there's no notifications Leveraging JMX in Debugging and Management JMX stands out as a robust tool for wiring management consoles, allowing developers to expose critical settings and metrics for their projects. Beyond its conventional use, JMX can be leveraged as part of the debugging process, serving as a pseudo-interface for triggering debugging scenarios or observing debugging sessions within the management UI. This approach not only simplifies the management of server applications but also enhances the developer's ability to diagnose and resolve issues efficiently. Exposing MBeans in Spring Boot Up until now, we discussed the process of working with beans that are a part of the JVM or Spring. But what about our own application logic? We can expose our own application’s internal state so we (and our SREs) can review these in production and staging. Instead of building a custom control panel or logging , we can just expose the data. If a flag is problematic we can change it in production, if you want to query a specific state it too can be exposed. everything Spring Boot simplifies the management and monitoring of applications through its comprehensive support for JMX. By leveraging Spring's infrastructure, we can easily expose their application's beans as JMX Managed Beans (MBeans), making them accessible for monitoring and management via JMX clients. Understanding Spring Boot JMX Support Spring Boot automatically configures JMX for you and exposes any beans annotated with as JMX MBeans. This feature, combined with Spring Boot’s Actuator, provides a rich set of management endpoints, covering various aspects of the application, from metrics to thread dumps. @ManagedResource Expose an MBean in Spring Boot To expose a bean, we need to take the following steps: : Create an interface that defines the operations and attributes you wish to expose via JMX. This interface should be annotated with JMX annotations such as for methods and for fields or getter/setter methods. Define a Management Interface @ManagedOperation @ManagedAttribute : Implement the interface in a class that performs the actual logic for the operations and attributes defined. This class represents your MBean and can be a regular Spring-managed bean. Implement the MBean : Annotate your MBean implementation class with to indicate that it should be exposed as an MBean. You can specify the object name for the MBean in this annotation, which is how it will be identified in JMX clients. Annotate the Bean with @ManagedResource @ManagedResource : Ensure that JMX is enabled in your Spring Boot application. This is usually the default behavior, but you can explicitly enable it by setting in your or file. Enable JMX in Spring Boot spring.jmx.enabled=true application.properties application.yml : Once your application is running, you can access the exposed MBean through any standard JMX client, such as JConsole, VisualVM, or a custom client. Connect to the Spring Boot application's JMX domain, and you'll find the MBean you exposed, ready for interaction. Access the MBean via a JMX Client Example: Exposing a Simple Configuration MBean // Define a management interface
public interface ConfigurationMBean {
    @ManagedAttribute
    String getApplicationName();

    @ManagedOperation
    void updateApplicationName(String name);
}

// Implement the MBean
@Component
@ManagedResource(objectName = "com.example:type=Configuration")
public class Configuration implements ConfigurationMBean {
    private String applicationName = "MyApp";

    @Override
    public String getApplicationName() {
        return applicationName;
    }

    @Override
    public void updateApplicationName(String name) {
        this.applicationName = name;
    }
} In this example, the class is annotated with , making it available as an MBean with operations and attributes accessible via JMX clients. Configuration @ManagedResource Exposing MBeans in Spring Boot is a powerful feature that enhances the management and monitoring capabilities of applications. By following the steps outlined above, developers can provide external tools with dynamic access to application internals, offering a window into the runtime behavior and allowing for adjustments on the fly. This not only aids in debugging and performance tuning but also aligns with best practices for building manageable, robust applications. Final Word Advanced management tools, particularly JMX and its integration with frameworks like Spring, offer developers powerful capabilities for application monitoring, configuration, and debugging. By understanding and utilizing these tools, developers can achieve a deeper level of control over their applications, enhancing both performance and reliability. Whether through graphical interfaces or command-line utilities like JMXTerm, the dynamic manipulation and monitoring of applications in runtime environments open new avenues for effective software development and management. As the bridge between development and operations continues to narrow, mastering these advanced tools becomes essential for any developer looking to excel in today's fast-paced technological landscape. Also published . here

Leveraging JMX for Efficient Debugging, Revisited

What company is more valuable, Microsoft or Apple? That's the question Wall Street wants to answer entering into 2024 as both firms compete head to head in a race to be crowned victor. With a market capitalization of over $3 trillion, Apple has been the most valuable company in the world for quite some time now, but after the ultra sensationalized success of Microsoft-backed OpenAI's ChatGPT, the Windows maker has slowly gained ground and finally broke the $3 trillion threshold to appear as a formidable challenger to the creator of iPhone. In fact, at the time of writing, Microsoft already was the most valuable company in the world, but in the infamous words of Dr. Dre, "Anybody can get it; The hard part is keepin' it, motherf*cker." So now the question is, will Microsoft remain the most valuable company in the world? Well.. Say what you will of Microsoft's business, products, and business products, the company holds a commendable sway over the industries it operates in. We're talking OSs; Productivity tools; Cloud; the list goes on. As we understand it, there's no part of the technology world that doesn't rely on or use a Microsoft product in some shape, way, or form to function, and that's precisely why the company has been able to invent and reinvent itself while staying relevant since the time it was founded by Bill Gates. Instead of wanting to sell products directly to customers, a majority of Microsoft's business has to do with offering tools to the people that make the products that then customers want to buy. And that's a very important distinction to make because that's what makes Microsoft a little different from Apple, which is very, very reliant on customer trends. Apple's entire business model has to do with making products people want, and it is very, very good at what it does. Apple products are cleverly designed, often innovative, and come with the oomph consumers are looking for, but there's really not a lot the company can do if people just can't (or won't!) buy its iPhones, as was the case recently when the company reportedly saw a 30% decline in the smartphone's sales in China due to growing competition from the likes of Huawei. And THAT perhaps is the biggest reason why the company's stock price has been taking a dip, leaving Microsoft with the opportunity to zoom on past ahead. Microsoft's stock also did phenomenally well last year, rising 57% in 2023 as compared to the 48% rise Apple shares experienced last year. So it's safe to say, the future, as it stands, belongs to Apple and Microsoft, at least, in terms of who is the most valuable — regardless of who is #1. So with Microsoft and Apple so far ahead, where does that leave the likes of Google and Amazon? Unfortunately for Google parent Alphabet, CEO Sundar Pichai's prediction that the success of ChatGPT was a code red for the company may be coming true since the company hasn't even reached the $2 trillion mark! Meanwhile, Amazon is stuck in a range of legal issues involving its business practices and finds itself at an even lower valuation than Google. The one rising star amongst all of these companies continues to be Nvidia, which not only became worth $1 trillion last year, has already experienced such a surge in its share price that it's already halfway through to adding anothertrillion to its market share. For those that don't know, Nvidia sells the hardware that makes generative AI possible. Anyway, it's going to be a wiiiiiiiiiiild ride this year and we'd be excited to see who comes up on top. Microsoft was ranked #1 on HackerNoon's Tech Company Rankingsthis week, followed by Apple at #3, Google at #5 and Amazon at #6. 👋 You’re reading HackerNoon's Tech Company News Brief, a weekly collection of tech goodness that combines HackerNoon's proprietary data with internet trends to determine which companies are rising and falling in the public consciousness. Subscribe here to receive the complete newsletter in your inbox every Tuesday. Reddit, Now Coming to a Stock Exchange Near You! 👽 Love it or hate it, Reddit is as much a part of the internet lexicon as Google or Facebook. Depending on what you fancy, there's almost always a community to be found, and some reddit threads are.. Well, classic. Reddit might not necessarily have the same corporate clout as traditional social media companies, or, atleast, the deep coffers that run in billions, but it does command sizable respect around the web, particularly as an outlet for some of the more niche communities. I mean, who hasn't turned to Reddit to find answers to burning questions about.. Ahem, bowel movements. Now, Reddit wants a seat at the big boys' table. Having been the platform where "meme stocks" originated, the social media company now wants to float its own stocks to the public market with a soon-to-be-coming initial public offering this year. According to media reports, the mecca of memes (4chan not counted because of Rule #1 😉) could file for an IPO as early as February, with plans to wrap up the entire process by the end of March. The IPO has been a long time coming, with the platform said to have sketched plans to go public as far back as 2021; for one reason or the other, the company held up on actually pulling the trigger, but the plan seems to be picking up steam. So how much is Reddit going to be worth? During its last funding round in 2021, the platform was said to be worth about $10 billion despite the fact that it has never come close to profitability. The valuation might sound like a lot until you realize that it's next to nothing when compared to the likes of Meta (close to a trillion dollars in valuation) and TikTok-owner Bytedance (hundreds of billions of dollars). Nonetheless, the public at large will have a chance to own a piece of the pie with the IPO which would see Reddit float 10% of its ownership in public markets. So keep your eyes peeled for when that happens! What's Up With Bitcoin? 🪙 To any crypto pundit who thought the world's largest currency was headed To the Moon™, what the heck is going on with Bitcoin?? Ever since the US Securities & Exchange Commission approved a bunch of spot bitcoin exchange traded funds (ETF), the price of the cryptocurrency keeps falling. In fact, as of the time of this writing, bitcoin has gone down to below $40,000 at least once! But don't worry, if you're just as confused as we are as to what's going on, we just might have the answer for you. The ETF approval was already pegged as a "sell-the-news" event by on-chain analysis firm CryptoQuant, one of the very few firms that warned bitcoin prices would go down following the SEC action. The firm continues to maintain that bitcoin will fall to around $32,000 as the market corrects itself, possibly spelling doom for Hodlers who got in the action when bitcoin was in the $40,000 range (unless said Hodlers have diamond hands). And if things continue the way they are, it's likely the firm's analysis will come true. But keeping aside what analysts say, part of the reason why bitcoin prices have gone down has to do with now defunct crypto exchange FTX, which apparently sold $1 billion worth of  Grayscale's Bitcoin ETF as part of its bankruptcy proceedings. Whether bitcoin is going to go up or down is anyone's guess, but it should be interesting to see how the crypto landscape evolves with the SEC's oversight (the cryptocurrency is already up back to $42k levels!). Fun fact: HackerNoon is running a poll asking the community what THEY think about the whole bitcoin pricing scenario, so feel free to add your voice to the discussion. In Other News.. 📰 NFTs Outpaced Ether's Gains in January — via CoinDesk
Elon Musk’s $56B Tesla pay deal is unfair, judge rules — via TechCrunch
MrBeast tested Elon Musk’s theory and took home $250,000 — via CNN
Investors punish Microsoft, Alphabet as AI returns fall short of lofty expectations — via Reuters
Tech rivals hound Apple over EU App Store plans — via Axios
Lawmakers to grill CEOs of Meta, TikTok, X and other social media firms at hearing on child safety — via CNBC And that's a wrap! Don't forget to share this newsletter with your family and friends See y'all next week. PEACE! ☮️ — Sheharyar Khan, Editor, Business Tech @ HackerNoon *All rankings are current as of Monday. To see how the rankings have changed, please visit HackerNoon's Tech Company Rankings page. What company is more valuable, Microsoft or Apple ? That's the question Wall Street wants to answer entering into 2024 as both firms compete head to head in a race to be crowned victor. Microsoft Microsoft Apple Apple With a market capitalization of over $3 trillion, Apple has been the most valuable company in the world for quite some time now, but after the ultra sensationalized success of Microsoft-backed OpenAI's ChatGPT, the Windows maker has slowly gained ground and finally broke the $3 trillion threshold to appear as a formidable challenger to the creator of iPhone. most valuable company most valuable company gained ground gained ground finally In fact, at the time of writing, Microsoft already was the most valuable company in the world, but in the infamous words of Dr. Dre, "Anybody can get it; The hard part is keepin' it, motherf*cker." was infamous words infamous words So now the question is, will Microsoft remain the most valuable company in the world? Well.. Say what you will of Microsoft's business, products, and business products, the company holds a commendable sway over the industries it operates in. We're talking OSs; Productivity tools; Cloud; the list goes on. As we understand it, there's no part of the technology world that doesn't rely on or use a Microsoft product in some shape, way, or form to function, and that's precisely why the company has been able to invent and reinvent itself while staying relevant since the time it was founded by Bill Gates. precisely Instead of wanting to sell products directly to customers, a majority of Microsoft's business has to do with offering tools to the people that make the products that then customers want to buy. And that's a very important distinction to make because that's what makes Microsoft a little different from Apple, which is very, very reliant on customer trends. Apple's entire business model has to do with making products people want, and it is very, very good at what it does. Apple products are cleverly designed, often innovative, and come with the oomph consumers are looking for, but there's really not a lot the company can do if people just can't (or won't!) buy its iPhones, as was the case recently when the company reportedly saw a 30% decline in the smartphone's sales in China due to growing competition from the likes of Huawei. And THAT perhaps is the biggest reason why the company's stock price has been taking a dip, leaving Microsoft with the opportunity to zoom on past ahead. Microsoft's stock also did phenomenally well last year, rising 57% in 2023 as compared to the 48% rise Apple shares experienced last year. So it's safe to say, the future, as it stands, belongs to Apple and Microsoft, at least, in terms of who is the most valuable — regardless of who is #1. rising rising So with Microsoft and Apple so far ahead, where does that leave the likes of Google and Amazon ? Unfortunately for Google parent Alphabet, CEO Sundar Pichai's prediction that the success of ChatGPT was a code red for the company may be coming true since the company hasn't even reached the $2 trillion mark! Meanwhile, Amazon is stuck in a range of legal issues involving its business practices and finds itself at an even lower valuation than Google. Google Google Amazon Amazon code red code red range of legal issues range of legal issues The one rising star amongst all of these companies continues to be Nvidia , which not only became worth $1 trillion last year, has already experienced such a surge in its share price that it's already halfway through to adding another trillion to its market share. For those that don't know, Nvidia sells the hardware that makes generative AI possible. Nvidia Nvidia $1 trillion $1 trillion surge surge another Anyway, it's going to be a wiiiiiiiiiiild ride this year and we'd be excited to see who comes up on top. wiiiiiiiiiiild wiiiiiiiiiiild Microsoft was ranked #1 on HackerNoon's Tech Company Rankings this week, followed by Apple at #3, Google at #5 and Amazon at #6. Tech Company Rankings 👋 You’re reading HackerNoon's Tech Company News Brief, a weekly collection of tech goodness that combines HackerNoon's proprietary data with internet trends to determine which companies are rising and falling in the public consciousness. Subscribe here to receive the complete newsletter in your inbox every Tuesday. 👋 You’re reading HackerNoon's Tech Company News Brief, a weekly collection of tech goodness that combines HackerNoon's proprietary data with internet trends to determine which companies are rising and falling in the public consciousness. Subscribe here to receive the complete newsletter in your inbox every Tuesday. You’re reading HackerNoon's Tech Company News Brief , a weekly collection of tech goodness that combines HackerNoon's proprietary data with internet trends to determine which companies are rising and falling in the public consciousness. Subscribe here to receive the complete newsletter in your inbox every Tuesday. Tech Company News Brief Tech Company News Brief here complete Reddit, Now Coming to a Stock Exchange Near You! 👽 Reddit, Now Coming to a Stock Exchange Near You! 👽 Love it or hate it, Reddit is as much a part of the internet lexicon as Google or Facebook. Depending on what you fancy, there's almost always a community to be found, and some reddit threads are.. Well, classic . classic classic Reddit might not necessarily have the same corporate clout as traditional social media companies, or, atleast, the deep coffers that run in billions, but it does command sizable respect around the web, particularly as an outlet for some of the more niche communities. I mean, who hasn't turned to Reddit to find answers to burning questions about.. Ahem, bowel movements . bowel movements bowel movements Now, Reddit wants a seat at the big boys' table. Having been the platform where "meme stocks" originated, the social media company now wants to float its own stocks to the public market with a soon-to-be-coming initial public offering this year. According to media reports, the mecca of memes (4chan not counted because of Rule #1 😉) could file for an IPO as early as February, with plans to wrap up the entire process by the end of March. The IPO has been a long time coming, with the platform said to have sketched plans to go public as far back as 2021; for one reason or the other, the company held up on actually pulling the trigger, but the plan seems to be picking up steam. Rule #1 Rule #1 So how much is Reddit going to be worth? During its last funding round in 2021, the platform was said to be worth about $10 billion despite the fact that it has never come close to profitability. The valuation might sound like a lot until you realize that it's next to nothing when compared to the likes of Meta (close to a trillion dollars in valuation) and TikTok-owner Bytedance (hundreds of billions of dollars). is Nonetheless, the public at large will have a chance to own a piece of the pie with the IPO which would see Reddit float 10% of its ownership in public markets. So keep your eyes peeled for when that happens! What's Up With Bitcoin? 🪙 What's Up With Bitcoin? 🪙 To any crypto pundit who thought the world's largest currency was headed To the Moon™, what the heck is going on with Bitcoin?? what the heck Ever since the US Securities & Exchange Commission approved a bunch of spot bitcoin exchange traded funds (ETF), the price of the cryptocurrency keeps falling. In fact, as of the time of this writing, bitcoin has gone down to below $40,000 at least once! below But don't worry, if you're just as confused as we are as to what's going on, we just might have the answer for you. The ETF approval was already pegged as a "sell-the-news" event by on-chain analysis firm CryptoQuant, one of the very few firms that warned bitcoin prices would go down following the SEC action. The firm continues to maintain that bitcoin will fall to around $32,000 as the market corrects itself, possibly spelling doom for Hodlers who got in the action when bitcoin was in the $40,000 range (unless said Hodlers have diamond hands). And if things continue the way they are, it's likely the firm's analysis will come true. warned warned But keeping aside what analysts say, part of the reason why bitcoin prices have gone down has to do with now defunct crypto exchange FTX, which apparently sold $1 billion worth of  Grayscale's Bitcoin ETF as part of its bankruptcy proceedings . bankruptcy proceedings bankruptcy proceedings Whether bitcoin is going to go up or down is anyone's guess, but it should be interesting to see how the crypto landscape evolves with the SEC's oversight (the cryptocurrency is already up back to $42k levels!). Fun fact: HackerNoon is running a poll asking the community what THEY think about the whole bitcoin pricing scenario, so feel free to add your voice to the discussion . voice to the discussion voice to the discussion In Other News.. 📰 In Other News.. 📰 NFTs Outpaced Ether's Gains in January — via CoinDesk Elon Musk’s $56B Tesla pay deal is unfair, judge rules — via TechCrunch MrBeast tested Elon Musk’s theory and took home $250,000 — via CNN Investors punish Microsoft, Alphabet as AI returns fall short of lofty expectations — via Reuters Tech rivals hound Apple over EU App Store plans — via Axios Lawmakers to grill CEOs of Meta, TikTok, X and other social media firms at hearing on child safety — via CNBC NFTs Outpaced Ether's Gains in January — via CoinDesk CoinDesk CoinDesk Elon Musk’s $56B Tesla pay deal is unfair, judge rules — via TechCrunch TechCrunch TechCrunch MrBeast tested Elon Musk’s theory and took home $250,000 — via CNN CNN CNN Investors punish Microsoft, Alphabet as AI returns fall short of lofty expectations — via Reuters Reuters Reuters Tech rivals hound Apple over EU App Store plans — via Axios Axios Axios Lawmakers to grill CEOs of Meta, TikTok, X and other social media firms at hearing on child safety — via CNBC CNBC CNBC And that's a wrap! Don't forget to share this newsletter with your family and friends See y'all next week. PEACE! ☮️ — Sheharyar Khan, Editor, Business Tech @ HackerNoon — Sheharyar Khan, Editor, Business Tech @ HackerNoon *All rankings are current as of Monday. To see how the rankings have changed, please visit HackerNoon's Tech Company Rankings page. *All rankings are current as of Monday. To see how the rankings have changed, please visit HackerNoon's Tech Company Rankings page. *All rankings are current as of Monday. To see how the rankings have changed, please visit HackerNoon's Tech Company Rankings page. Tech Company Rankings Tech Company Rankings

Microsoft, Apple Trade Blows For Top Spot

I write a newsletter called Above Average, where I talk about the second-order insights behind everything that is happening in the big tech. If you are into tech and don’t want to be average, . subscribe to it Inferring is essentially a way to extract insights, sentiments, and trends using clever prompts while interacting with LLMs. Previously, before LLMs, each of these tasks would require their own models, training, and deployment & maintenance. But with the explosion of OpenAI and other LLMs, inference allows you to improve your products by leveraging LLMs, and you don’t have to be a data scientist or a machine learning engineer to do so. Let’s say you run an e-commerce website and want to extract the sentiment of customer reviews. You can do this using the following prompt. In this case, I am providing the review text and the prompt you can use on it. You can use your favorite way to run it against Open AI’s API. I took a real review from Amazon for a light box that I purchased for this example. Example 1: from openai import OpenAI
client = OpenAI()
client.api_key = 'YOUR_SECRET_KEY'

amazon_review = f"""
This softbox lighting system is a great value for the price. They were super easy to set and offer multiple types of lighting, with dimmer and remotes for each light. They are lightweight which means they can topple over if bumped. But that was an easy problem to solve. I just created some weights out of an old pair of socks and some dried beans. You could use rice or sand also. Or just buy sandbags. I like to DIY. Anywho, I highly recommend this lighting system.
"""

story = """
prompt = f"""
Identify the following items from the review text: 
- Sentiment (positive or negative)
- Is the reviewer expressing anger? (true or false)
- Item purchased by reviewer
- Company that made the item

The review is delimited with triple backticks. \
Format your response as a JSON object with \
"Sentiment", "Anger", "Item" and "Brand" as the keys.
If the information isn't present, use "unknown" \
as the value.
Make your response as short as possible.
Format the Anger value as a boolean.

Review text: '''{amazon_review}'''

"""

response = client.chat.completions.create(
  model="gpt-4",
  messages=[
    {
      "role": "user",
      "content": prompt
    }
  ],
  temperature=0,
  #max_tokens=64,
  #top_p=1
)

print(response.choices[0].message.content) The output I got is as follows: {“Sentiment”: “positive”, “Anger”: false, “Item”: “softbox lighting system”, “Brand”: “unknown”} This is a cool example showing the power of inferring using Open AI’s API. Now, Amazon is a large company that already uses AI to ship features, and one of the recent updates to the page seems to be about summarizing all the reviews under the product. Here is how it looks for the same product. Do you think it can be re-created using inferring across a set of customer reviews? I think so. If you are able to figure this out, reach me on and let me know. Twitter let's say you run a news website, and you want to find the topics an article is about without actually reading it. Can you do it using a Prompt and infer it? Yes, you can. Here is an example article from which I am inferring topics mentioned in that article. Example 2: from openai import OpenAI
client = OpenAI()
client.api_key = 'YOUR_SECRET_KEY'



article = """
It hasn't been the best start to 2024 for Elon Musk. The owner of X, formerly known as Twitter, appealed to YouTube's biggest star MrBeast to post his videos on the platform, and was promptly rejected.

On Dec. 30, 2023, MrBeast, whose real name is Jimmy Donaldson, posted on X to announce his latest video release was available on YouTube: "I uploaded, go watch or I'll drop kick you."

Donaldson had uploaded a 20-minute long video to YouTube, in which he chronicled spending a week in solitary confinement. These types of videos, in which Donaldson challenges either himself or an individual with an extreme task, have earned him worldwide notoriety. The social media mastermind earned an estimated $82 million in 2023, and with more than 225 million subscribers on his main channel alone, is the platform's biggest name.

After Donaldson posted the appeal to head to YouTube on X, one fan replied: "Upload on this platform too," which is when Elon Musk chimed in with: "Yeah."

Musk, the CEO of Tesla and owner of X, has been trying to drum up interest from video viewers since taking over the social media platform in 2022.

Schemes have included launching a media partnership with heiress Paris Hilton—which has since been axed—as well as streaming shows from the likes of former Fox star Tucker Carlson.

Musk, now with the help of CEO Linda Yaccarino, has also attempted to drum up revenue by launching premium subscription services on the site, which—among other things—allow for users to appear as "verified" and send DMs to other accounts.

The moves have been necessary after droves of advertisers left the site over fears their branding would appear beside unregulated content.

Musk, a fierce proponent of free speech, has refused to cow to concern from advertisers about how X will prevent their messages from reportedly appearing beside Nazi propaganda, for example.

But Musk's attempt to get MrBeast's content on his site—not even exclusively—was rebuffed by the creator.

Donaldson replied to Musk directly: "My videos cost millions to make and even if they got a billion views on X it wouldn’t fund a fraction of it :/ I’m down though to test stuff once monetization is really cranking!"

The polite rebuttal contrasts with the firm interest Donaldson had previously taken in Twitter. Indeed, Donaldson's bio still reads "X Super Official CEO," harking back to the times when speculation was rife about who would take over the day-to-day running of the platform from the ever-busy Musk.
"""

prompt = f"""
Determine five topics that are being discussed in the \
following text, which is delimited by triple backticks.

Make each item one or two words long. 

Format your response as a list of items separated by commas.

Text sample: '''{article}'''

"""

response = client.chat.completions.create(
  model="gpt-4",
  messages=[
    {
      "role": "user",
      "content": prompt
    }
  ],
  temperature=0,
  #max_tokens=64,
  #top_p=1
)

print(response.choices[0].message.content) Output is: Elon Musk, Social Media Platforms, YouTube Content, Advertising Concerns, Monetization Strategies Pretty accurate, right? Shopify App to summarize & extract insights from customer reviews. This app should be launched in the Shopify app store. I wouldn’t be surprised if Shopify launched this natively. Just using prompt engineering with open AI API, this would be an app that can be launched in a couple of days. AI PRODUCT IDEA ALERT: That’s it for day 3. Follow me on for the latest updates on 100 days of AI, or . Twitter bookmark this page Also published . here

100 Days of AI Day 3: Leveraging AI for Prompt Engineering and Inference

AI দিনের 100 দিন 3: প্রম্পট ইঞ্জিনিয়ারিং এবং ইনফরেন্সের জন্য AI ব্যবহার করা

100 Tage KI Tag 3: Nutzung von KI für schnelles Engineering und Inferenz

100 días de IA Día 3: Aprovechamiento de la IA para ingeniería e inferencia rápidas

100 jours d'IA Jour 3 : Tirer parti de l'IA pour une ingénierie et une inférence rapides

एआई के 100 दिन, दिन 3: त्वरित इंजीनियरिंग और अनुमान के लिए एआई का लाभ उठाना

100 日間の AI 3 日目: AI を活用して迅速なエンジニアリングと推論を行う

AI 100일 3일차: 신속한 엔지니어링 및 추론을 위해 AI 활용

100 dias de IA, dia 3: aproveitando a IA para engenharia e inferência imediatas

100 дней ИИ. День 3. Использование ИИ для оперативного проектирования и вывода

100 Günlük Yapay Zeka 3. Gün: Hızlı Mühendislik ve Çıkarım için Yapay Zekadan Yararlanma

100 ngày AI Ngày 3: Tận dụng AI cho Kỹ thuật và suy luận nhanh chóng

人工智能 100 天第 3 天：利用人工智能进行快速工程和推理

What is the problem? Async await syntax gives us the most straightforward way to write asynchronous code. However, such construction cannot be used in certain scenarios. For instance, using async await keywords is prohibited in constructors. There are many reasons why it is not possible in the existing language version. Probably, one of the obvious ones is that async methods would return or to be able to properly handle exceptions without crashing the process, and trivially to be able to wait until the async operation is completed. Task Task<T> And if we simply take the following class, build the library containing it, and then look at disassembled code. public class MyObject
{
    public MyObject()
    {
        //diligently initializing
    }
} We will see the following line. instance void [System.Runtime]System.Object::.ctor() where the keyword indicates that the method is an instance method, meaning it is called on an instance of the class, not on the class itself (which would be indicated by the static keyword). instance So, technically, it calls some method (constructor) on the already existing object to initialize it. Could it be made asynchronous hypothetically? public class MyObject
{
    public async MyObject()
    {
        await InitializeAsync();
    }
} Of course, yes, everything is possible in our world; it only depends on the price and whether it will solve any real problem without introducing new complications and tradeoffs. I believe that developers have had discussions about it many times, and they clearly understand the feasibility and meaningfulness of incorporating this change. C# language However, even without language in-built such a feature, we can solve this problem. Ways to overcome There are plenty of approaches that could be used to achieve the asynchronous initialization. Async to sync If we are only allowed to have sync operation in constructors, we can intuitively apply the approach. async to sync public class MyBestObject
{
    public MyBestObject()
    {
        InitializeAsync().GetAwaiter().GetResult();
    }

    private async Task InitializeAsync()
    {
        //diligently initializing

        await Task.Delay(100);
    }
} This approach is not so bad if there is no synchronization context in place and the async operation is relatively fast, but in general, it is not a recommended practice since it is based on a lot of assumptions about the executing environment and details of the async operation. It leads to inefficient resource consumption, sudden deadlocks in UI applications, and a common violation of the async programming idea of “async all the way.“ Async factory A quite standard way for solving this problem is to use factories. public class MyBestService
{
    public async Task InitializeAsync() 
    {
        //diligently initializing

        await Task.Delay(100);
    }
}

public interface IMyBestServiceFactory
{
    Task<MyBestService> CreateAsync(CancellationToken cancellationToken);
}

public sealed class MyBestServiceFactory : IMyBestServiceFactory
{
    public MyBestServiceFactory()
    {
    }

    public async Task<MyBestService> CreateAsync(CancellationToken cancellationToken)
    {
        var service = new MyBestService();
        await service.InitializeAsync(cancellationToken);
        return service;
    }
} We could either use the static method in class or even specify a dedicated factory for that purpose. The second option is a little bit more compatible with the pattern since you can request in any class and then just call the method. MyBestService Dependency Injection IMyBestServiceFactory CreateAsync The main drawback of this approach is additional coupling since you (any class uses ) need to control the lifetime of a newly created object. IMyBestServiceFactory Additionally, it requires adapting solutions that use reflection ( ) or expressions ( ) to create and initialize instances. Activate.CreateInstace Expression.New Async initialization We could do the following trick to avoid problems with the pattern. Async Factory public class MyBestService
{
    private readonly Task _initializeTask;

    public MyBestService()
    {
        _initializeTask = InitializeAsync();
    }

    public async Task DoSomethingAsync() 
    {
        await _initializeTask;

        // Do something async
    }

    private async Task InitializeAsync()
    {
        //diligently initializing

        await Task.Delay(100);
    }
} As you can see, we are beginning asynchronous initialization in the constructor and saving the reference to the started task. Then, before doing any meaningful operation, we check that is completed by simply awaiting it. _initializeTask The using of this approach is very usual both in cases with a self-instantiating way of objects and IoC container. var myBestService = new MyBestService();
await myBestService.DoSomethingAsync(); However, this approach has several drawbacks: Lack of control over the initialization process. For instance, we cannot simply pass . CancellationToken It gives the caller an incompletely instantiated object for a while. Although it does not seem a problem in general, it could lead to more complicated debugging if the initialization operation takes too long. Also, calling operation timeout might be less than the required amount of time for this particular object which apparently will lead to issues during the execution. Real example For applications to access Azure services like storage, key vault, or cognitive services, authenticating with Azure is mandatory, regardless of their deployment environment - on Azure, on-premises, or locally during development. There are several ways it could be achieved, and one of the most secure ones is utilising the approach with the class in .NET DefaultAzureCredential That’s what Microsoft says about it The class provided by the Azure SDK allows apps to use different authentication methods depending on the environment they're run in. This allows apps to be promoted from local development to test environments to production without code changes. You configure the appropriate authentication method for each environment and will automatically detect and use that authentication method. The use of should be preferred over manually coding conditional logic or feature flags to use different authentication methods in different environments. DefaultAzureCredential DefaultAzureCredential DefaultAzureCredential So, in order to securely store PII (Personally Identifiable Information) which can be either Full name, Phone Number, Credit card number, or Social security number, we would like to encrypt it before storing it somewhere and provide viewing original value with only limited access. One of the possible ways is to use AzureKeyVault API for encryption and decryption. Although there is no huge impact of creating every time, to reduce latency and improve efficiency, it is preferable to have a single instance of it for the whole application. DefaultAzureCredential So, to prepare for encryption and decryption API, we need to have the following lines CryptographyClient var tokenCredential = new DefaultAzureCredential();
var keyClient = new KeyClient(new Uri(_configuration.KeyVaultUri), tokenCredential);
KeyVaultKey key = await keyClient.GetKeyAsync(_configuration.KeyName);
_cryptographyClient = new CryptographyClient(key.Id, tokenCredential); To avoid running them on every request, we can utilise described above Async initialisation internal sealed class DefaultAzureVaultAdapter : IAzureVaultAdapter
{
    private readonly AzureVaultConfiguration _configuration;
    private EncryptionAlgorithm _encryptionAlgorithm = EncryptionAlgorithm.RsaOaep256;
    private CryptographyClient _cryptographyClient = null!;
    private Task _initializationTask = null!;

    public DefaultAzureVaultAdapter(AzureVaultConfiguration configuration)
    {
        _configuration = configuration;
        _initializationTask = InitializeAsync();
    }

    public async Task<string> EncryptAsync(string value, CancellationToken cancellationToken)
    {
        await _initializationTask;

        byte[] inputAsByteArray = Encoding.UTF8.GetBytes(value);

        EncryptResult encryptResult = await _cryptographyClient.EncryptAsync(_encryptionAlgorithm, inputAsByteArray, cancellationToken);

        return Convert.ToBase64String(encryptResult.Ciphertext);
    }

    public async Task<string> DecryptAsync(string value, CancellationToken cancellationToken)
    {
        await _initializationTask;

        byte[] inputAsByteArray = Convert.FromBase64String(value);

        DecryptResult decryptResult = await _cryptographyClient.DecryptAsync(_encryptionAlgorithm, inputAsByteArray, cancellationToken);

        return Encoding.Default.GetString(decryptResult.Plaintext);
    }

    private async Task InitializeAsync()
    { 
        if (_cryptographyClient is not null)
            return;

        var tokenCredential = new DefaultAzureCredential();
        var keyClient = new KeyClient(new Uri(_configuration.KeyVaultUri), tokenCredential);
        KeyVaultKey key = await keyClient.GetKeyAsync(_configuration.KeyName);
        _cryptographyClient = new CryptographyClient(key.Id, tokenCredential);
    }
} And finally, register our with a singleton in IoC container. AzureVaultAdapter public static class ServiceCollectionExtensions
{
    public static IServiceCollection AddAzureVaultAdapter(this IServiceCollection services)
    {
        services.TryAddSingleton<IAzureVaultAdapter, DefaultAzureVaultAdapter>();
        return services;
    }
} Conclusion In this article, I covered several approaches for asynchronous object initialisation. Understanding requirements is the key to choosing the right approach. You can find the source code used to describe these patterns in this repository. https://github.com/alex-popov-stenn/CSharpAsyncInitPatterns/tree/main Thank you for reading! See you next time!

Asynchronous Initialization in C#: Overcoming Constructor Limitations

, designed specifically for the , brings a wealth of features and enhancements that cater to various monitoring needs for applications. Red Hat’s latest build of Cryostat 2.4 Red Hat OpenShift Container Platform Java At its core, Cryostat 2.4 excels in comprehensive Java Flight Recorder (JFR) data management. Users can effortlessly start, stop, retrieve, archive, import, and export JFR data, all through an intuitive web console or an accessible HTTP API. This enhances the ease with which developers can handle JVM performance data. Moreover, Cryostat 2.4 provides flexibility in terms of data storage and analysis. Users can store and analyze JFR data directly on their Red Hat OpenShift or export it to external monitoring applications for a deeper dive into the data. ARM (aarch64) A significant enhancement in Cryostat 2.4 is its support for Red Hat OpenShift Container Platform 4.11 and later versions, particularly for the ARM64 (aarch64) architecture. This broadens its applicability across various platforms, making it a versatile tool in diverse environments, e.g., edge deployments. Smart triggering and HTTP API Another notable feature is the introduction of dynamic JFR recording with MBean custom triggers. The Cryostat agent is equipped with smart triggers that continuously monitor MBean counter values such as runtime, memory, thread, and operating system metrics. Users are able to set custom trigger conditions, thereby adding a layer of precision to JVM monitoring. Further enhancing its functionality, Cryostat 2.4 introduces an improved HTTP API provided by the Cryostat agent. This serves as an alternative to an application’s JMX port, allowing users to fully utilize Cryostat’s features without the need for JMX port exposure in target applications. This is particularly beneficial for enhancing security and simplifying configurations. JAR distribution Cryostat 2.4 also offers flexibility in agent deployment. It provides two types of agent JAR file distributions—an all-in-one “shaded” JAR file that includes all dependencies and a standard JAR file containing only the agent code. This choice caters to different user requirements and helps manage potential dependency conflicts more effectively. Topology dashboard view Additionally, Cryostat 2.4 brings new features and fixes to enhance user experience. The Topology and Dashboard views in the Cryostat web console now display additional information about target JVMs, such as operating system names, memory statistics, class paths, library paths, input arguments, and system properties. The introduction of a parameter to restart flight recordings offers more control over recording management, addressing a common user pain point. Significant issues from previous versions have also been addressed. Automated rule-triggering issues in discovered JVM targets have been resolved, with Cryostat performing regular rechecks and reattempts at rule triggering. This ensures a more reliable connection with JVMs, improving consistency and predictability. The agent registration protocol has also seen improvements, resolving issues related to agent registration with the Cryostat server and ensuring a smoother, more reliable process. Cryostat 2.4 is a testament to Red Hat’s commitment to providing robust and innovative solutions for modern containerized applications. With its enhanced features, improved user experience, and greater flexibility, Cryostat 2.4 is poised to be a pivotal tool in JVM monitoring, offering a sophisticated and user-friendly approach to performance monitoring in containerized environments. How to use Cryostat for your Java workloads You can using our OpenShift operator, available in ’s Operator Hub. For non-production usage, you can also try our Helm chart, included as part of OpenShift’s Helm chart repository. You can also try the Red Hat build of Cryostat . install the Red Hat build of Cryostat Red Hat OpenShift here Get support for Java Support for Cryostat, OpenJDK, and Eclipse Temurin is available to Red Hat customers through a subscription to , , and Red Hat OpenShift. Contact your local Red Hat representative or for more details. You can expect support for Java and other runtimes as described under the . Red Hat Runtimes Red Hat Enterprise Linux Red Hat sales Red Hat Product Update and Support Lifecycle Resources Catch up with the latest on Java Video: What is Eclipse Temurin? Getting started with Eclipse Temurin Red Hat joins the Eclipse Adoptium Working Group Eclipse Adoptium achieves its first Java SE release Red Hat Introduces Commercial Support for OpenJDK on Microsoft Windows The history and future of OpenJDK

Java Monitoring With Red Hat: Exploring Cryostat 2.4 features on OpenShift 

Smart Contract Security in Solidity

সলিডিটিতে স্মার্ট কন্ট্রাক্ট সিকিউরিটি

Intelligente Vertragssicherheit in Solidität

Una encuesta de 2023 sobre seguridad de contratos inteligentes para la solidez

Une enquête 2023 sur la sécurité des contrats intelligents pour la solidité

सॉलिडिटी के लिए स्मार्ट कॉन्ट्रैक्ट सिक्योरिटी पर 2023 का सर्वे

Solidity のスマート コントラクト セキュリティに関する 2023 年の調査

Solidity의 스마트 계약 보안

Uma pesquisa de 2023 sobre segurança de contratos inteligentes para solidez

Sağlamlıkta Akıllı Sözleşme Güvenliği

Khảo sát năm 2023 về bảo mật hợp đồng thông minh cho sự vững chắc

2023 年 Solidity 智能合约安全性调查

As the NFT area is growing every day, more new mechanics and experiments are coming to the world of priceless pixels. One of the popular approaches during NFT launches is a Reveal toggle functionality. Reveal functionality stands for hiding the NFT picture with some placeholder image initially. In this article we will go through the process of implementing such behavior and analyze why you’d possibly use it in your collection. Theory Firstly, let’s dive into the theory of NFTs to define the steps needed for our Reveal. NFTs are following standard of a non-fungible token and all of the generative collections follow interface as well. ERC721 ERC721Metadata interface ERC721Metadata {    
  function name() external view returns (string _name);
  function symbol() external view returns (string _symbol);   
  function tokenURI(uint256 _tokenId) external view returns (string);
} This interface allows us to specify name, symbol and tokenURI for each NFT in our collection. What we are interested here is function that is responsible for returning item’s metadata value. tokenURI So our task for implementing Reveal is the following: Create a flag variable in Smart Contract that indicates whether NFTs are hidden/revealed Add external function for toggling (or setting to true) flag variable value, that has to be accessed only by owner Override method to return the same single metadata file for every NFT during the Hidden phase and appropriate NFT metadata after reveal tokenURI Upload Hidden phase metadata to IPFS Updating Smart Contract I won’t go deep with explaining the common NFT smart-contract, assuming that you have one already ;) If not, then have a look on standard that provides gas-efficient minting, so your customers won’t pay a lot for transaction fee. I’ll be using ERC721A in this tutorial as well. ERC721A Let’s add the flag property to existing Contract class and initialize it with : false bool public revealed = false; Then let’s add a function for changing our value and make sure it could only be called by the . For doing that, I’d suggest derive from the OpenZeppelin contract that will add modifier for us. revealed owner Ownable onlyOwner contract HiddenReveal is ERC721A, Ownable {
  bool public revealed = false;  
  function reveal() external onlyOwner {revealed = true;}
} As you can see, I’m not toggling the value but just set it . In this way you won’t make your community nervous that you might hide their NFTs again after revealing 🙃 You can make it to toggle current value or set to the value passed into the function. revealed true Now is the most interesting part: overriding function based on our flag. tokenURI revealed function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
  if (!_exists(tokenId)) revert URIQueryForNonexistentToken();
  string memory baseURI = _baseURI();  
  string memory metadataPointerId = !revealed ? 'unrevealed' : _toString(tokenId);  
  string memory result = string(abi.encodePacked(baseURI, metadataPointerId, '.json'));  

  return bytes(baseURI).length != 0 ? result : '';  
} Check if token with such exists and revert with Custom Error if not tokenId Take the value to concat it with and get metadata URL baseURI tokenId Check the current state and if it’s then use string instead of , store it into revealed false unrevealed tokenId metadataPointerId Concat , and extension baseURI metadataPointerId .json Return the is baseURI is specified result Final result for will be something like this, for every NFT: revealed=false or https://www.mybaseurilink.com/folderipfshash/unrevealed.json ipfs://folderipfshash/unrevealed.json Here is the full Smart Contract code with Hide/Reveal functionality: contract HiddenReveal is ERC721A, Ownable {
  string private _baseTokenURI;
  bool public revealed = false;  

  function _baseURI() internal view virtual override returns (string memory) {  
    return _baseTokenURI;  
  }  

  function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {  
    if (!_exists(tokenId)) revert URIQueryForNonexistentToken();  

    string memory baseURI = _baseURI();  
    string memory metadataPointerId = !revealed ? 'unrevealed' : _toString(tokenId);  
    string memory result = string(abi.encodePacked(baseURI, metadataPointerId, '.json'));  

    return bytes(baseURI).length != 0 ? result : '';  
  }  

  function setBaseURI(string calldata baseURI) external onlyOwner {  
    _baseTokenURI = baseURI;  
  }  

  function reveal() external onlyOwner {  
    revealed = true;  
  }
} Please, note that this Smart Contract is NOT production ready, as it doesn’t have mint functions lol. But you can use it as a reference to plug functionality into your solution Setting Up IPFS After finishing with Smart Contract part, you have to set up the storage for your Unrevealed items metadata. Generally, you will just need to store a placeholder image and metadata files in a separate IPFS folder. unrevealed.json Then you connect your Smart Contract to the IPFS storage through calling on contract with the folder’s hash. setBaseURI Here is an example of : unrevealed.json {
  "name": "@sir_fedos Hide/Reveal",
  "description": "Tutorial on how to create Reveal functionality on your NFT",
  "image": "ipfs://hAshToYoUrPlAcEhoLderImAge"
} Conclusion All in all, Reveal functionality is a great marketing tool and a tiny mechanic that could be added to every NFT drop with ease. Moreover, you can specify multiple reveal stages, define them as an enum and add some entertainment to the post-mint phase of your project! Follow for more tutorials! Also published . here

How to Create an NFT Reveal With Solidity

Since I started working for , I have tried to deepen my understanding of REST via various means. Did you read my review of ? Apache APISIX API Design Patterns book In the current literature, REST is generally promoted as the best thing since sliced bread. Yet, it comes with lots of challenges. In 2010(!), Martin Fowler wrote a post on the . He lists three steps for an API to become REST: glory of REST truly In each of these steps, issues lurk. This blog post focuses on listing some of them and providing hints at ways to solve them. Resources REST emerged from the cons of SOAP. SOAP provides a single endpoint and executes code depending on the payload. The idea of REST is to provide multiple endpoints, which each executes different code. I'll be honest; there are a few issues at this stage. The biggest one relates to guessing one identity from an existing one. If resource ids are sequential or even only numeric, it's easy to guess other resources' endpoints, , from to . e.g. /customers/1 /customers/2 The solution is to use non-sequential non-numeric ids, , . i.e. Universally unique identifiers Let's walk up the REST maturity model. HTTP Verbs HTTP verbs are the next step toward the glory of REST. They come from interactions with HTML "back in the day". Interactions came from Create Read Update Delete(CRUD) operations. It's pretty straightforward: Operation Verb Create POST Read GET Update PUT PATCH Delete DELETE The main problem with APIs is that you need to go beyond CRUD. Let's imagine a concrete example with a bank transfer: it takes money from one account and moves it to another one. How shall we model it? We could use the origin account as the resource, , . The target account, the amount, etc., can be passed as query parameters or in the body. But what HTTP verb shall we use? e.g. /accounts/a1b2c3d4e5f6 It changes the identified resource indeed, but it has "side-effects": it also changes another resource, the target account. Here are a couple of options on how to manage the HTTP verb: Use because it changes the source resource. It's misleading because it doesn't tell about side effects. POST Use a dedicated HTTP verb, , . It's not self-explanatory and is opposite to REST principles. e.g. TRANSFER Use with a so-called . Custom methods are a Google : POST custom method API Improvement Proposal Custom methods should only be used for functionality that can not be easily expressed via standard methods; prefer standard methods if possible, due to their consistent semantics. The HTTP URI use a character followed by the custom verb. must : Here's our bank account transfer URI: . /accounts/a1b2c3d4e5f6:transfer What's the best alternative? "It depends". Hypermedia Fowler describes Hypermedia Controls as the ultimate step to reaching the glory of REST. It's nowadays known as Hypermedia As The Engine of Application State(HATEOAS): With HATEOAS, a client interacts with a network application whose application servers provide information dynamically through hypermedia. A REST client needs little to no prior knowledge about how to interact with an application or server beyond a generic understanding of hypermedia. -- HATEOAS on Wikipedia HATEOAS is a concept; here's a possible implementation taken from Wikipedia. When one requests a bank account, say , the response contains links to actions possible with this specific bank account: /accounts/a1b2c3d4e5f6 {
  "account": {
    "account_number": "a1b2c3d4e5f6",
    "balance": {
      "currency": "USD",
      "value": 100.00
    },
    "links": {
      "_self": "/accounts/a1b2c3d4e5f6",
      "deposit": "/accounts/a1b2c3d4e5f6:deposit",
      "withdrawal": "/accounts/a1b2c3d4e5f6:withdrawal",
      "transfer": "/accounts/a1b2c3d4e5f6:transfer",
      "close-request": "/accounts/a1b2c3d4e5f6:close-request"
    }
  }
} If the balance is negative, only the deposit link will be available: {
  "account": {
    "account_number": "a1b2c3d4e5f6",
    "balance": {
      "currency": "USD",
      "value": 100.00
    },
    "links": {
      "_self": "/accounts/a1b2c3d4e5f6",
      "deposit": "/accounts/a1b2c3d4e5f6:deposit",
    }
  }
} A common issue with REST is the lack of standards; HATEOAS is no different. The first attempt to bring some degree of standardization was the , HAL. Note that it was incepted in 2012; the latest version dates from 2016, and it's still in draft. JSON Hypertext Application Language aka Here's a quick diagram that summarizes the proposal: We can rework the above with HAL as the following: GET /accounts/a1b2c3d4e5f6 HTTP/1.1
Accept: application/hal+json

HTTP/1.1 200 OK
Content-Type: application/hal+json

{
  "account": {
    "account_number": "a1b2c3d4e5f6",
    "balance": {
      "currency": "USD",
      "value": 100.00
    },
    "_links": {                                    <1>
      "self": {                                    <2>
        "href" : "/accounts/a1b2c3d4e5f6",
        "methods": ["GET"]                         <3>
      },
      "deposit": {
        "href" : "/accounts/a1b2c3d4e5f6:deposit", <4>
        "methods": ["POST"]                        <3>
      }
    }
  }
} Available links Link to self Tell which HTTP verb can be used Link to deposit Another attempt at standardization is , Web Linking. It describes the format and contains a , , and . The most significant difference with HAL is that RFC 8288 communicates links via HTTP response headers. RFC 8288 aka link relationship registry e.g. alternate copyright HTTP/2 200 OK

Link: </accounts/a1b2c3d4e5f6> rel="self";
                               method="GET",                           <1>
      </accounts/a1b2c3d4e5f6:deposit> rel="https://my.bank/deposit";
                                       title="Deposit";
                                       method="POST"                   <2>
{
  "account": {
    "account_number": "a1b2c3d4e5f6",
    "balance": {
      "currency": "USD",
      "value": 100.00
    }
  }
} Link to the current resource with the non-standard relation type self Link to deposit with the extension relation type and an arbitrary target attribute https://my.bank/deposit title Other alternative media types specifications are available. Name Description Provided by Uniform Basis for Exchanging Representations The UBER document format is a minimal read/write hypermedia type designed to support simple state transfers and ad-hoc hypermedia-based transitions. This specification describes both the XML and JSON variants of the format and provides guidelines for supporting UBER-encoded messages over the HTTP protocol. Individuals Collection+JSON Collection+JSON is a JSON-based read/write hypermedia-type designed to support the management and querying of simple collections Individual JSON: API JSON: API is a specification for how a client should request that resources be fetched or modified, and how a server should respond to those requests. JSON: API can be easily extended with extensions and profiles. Individuals Siren Siren is a hypermedia specification for representing entities. As HTML is used for visually representing documents on a Web site, Siren is a specification for presenting entities via a Web API. Siren offers structures to communicate information about entities, actions for executing state transitions, and links for client navigation. Individual Application-Level Profile Semantics An ALPS document can be used as a profile to explain the application semantics of a document with an application-agnostic media type (such as HTML, HAL, Collection+JSON, Siren, etc.). This increases the reusability of profile documents across media types. IETF Bonus: HTTP Response Status What Fowler's post doesn't mention is the HTTP response status. Most readers are familiar with the status ranges: Informational responses: 100 – 199 Successful responses: 200 – 299 Redirection messages: 300 – 399 Client error responses: 400 – 499 Server error responses: 500 – 599 Likewise, most are also with regularly-found HTTP status: , 200 OK , 301 Moved Permanently , 302 Found , 401 Unauthorized , 403 Forbidden and 404 Not Found . 500 Internal Server Error The problem is that beyond these simple cases, it's a mess. For example, look at this : "Which HTTP status code means Not Ready Yet, Try Again Later?" Here is a summary of the proposed answers, from the most upvoted to the lowest: StackOverflow question 503 Service Unavailable 202 Accepted (accepted answer) 423 Locked 404 Not Found 302 Found 409 Conflict 501 Not Implemented (downvoted) It's not a straightforward answer; there was a lot of debate around the alternatives. For the record, I think the accepted answer is the right one. That's already a lot on the designer side, but the client side contains a lot of uncertainty, too, as some big APIs providers use their . own HTTP status codes Conclusion The "glory of REST" doesn't mean much. There's no univocal semantics to rely on, despite any opposite claim. As it is, it depends mainly on the implementation and interpretation: both require documenting the custom behavior instead of relying on a shared specification. SOAP's biggest flaw was its complexity and its focus on big companies, but it at least provided a shared set of standard specifications. The industry replaced it with REST, not a specification but an architectural site. REST is simpler and, thus, more approachable, but it requires a lot of custom effort, which changes from project to project. There are initiatives to provide some standardization, but they are few, and some are at odds with others. Moreover, they have low traction, so people don't know them, which creates a vicious circle. I hardly advocate getting back to SOAP, though I sure miss it sometimes. Originally published at on January 22nd, 2023 A Java Geek

The Glory of REST: Is It Really That Glorious? 

is a new source control system developed by Meta. Recently, it gains the ability to work with GitHub. I’m curious about how it works, so I decided to give it a try and end up using it daily on my company’s repositories. If you want to try it out, check . Sapling their documentation here Stacked PRs When developing, I usually create a single commit for each PR and stack them together. To give an example, let’s say we are developing the sign-up feature: user inputs their email address, password, and we send them a nice welcome email. From the backend perspective, we need to create a new user, verify that the user doesn’t exist, and send the email. We need to touch the implementation of the cache package, add an email package, then finally implement the sign-up logic. This can be represented as a stack of PRs: Update package to add a new method. the cache Add . It uses the package to prevent sending duplicated emails. the email sending system cache Implement . It depends on the two changes above. the sign-up logic : This help reviewers with separation of concern. Smaller, isolated changes are easier to be reviewed. They can check the PRs one by one, with each PR containing independent logic. Of course, the email system still requires the cache package to be updated, but we can still review the email system in isolation. The benefit When the origin gets updated, we’ll pull the changes and rebase the PRs on top of the origin, push the changes, get reviewed, and merge. *The downside:*It requires discipline to keep the PRs small and isolated. Usually, while developing the upper PRs, we need to make some changes in the lower PRs. This can be annoying since we have to keep track of what changes in what PR, or constantly switch between PRs to make changes, then rebase the upper ones. git checkout mybranch/signup   # checkout sign up branch
vim features/signup/signup.go  # make changes to signup
vim lib/email/email.go         # make changes to email package

git add features/signup        # commit the signup changes        
git commit --amend             
git stash                      # stash the cache changes
git checkout mybranch/email    # checkout email branch
git stash pop                  # apply the cache changes
git add lib/email              # commit the email changes
git commit --amend
git checkout mybranch/signup   # checkout sign up branch again
git rebase mybranch/email      # rebase the signup branch on top of email branch Too much switching, and too many commands to type. It’s not fun. Enter sapling Sapling is a new git client. It encourages the use of stacked PR. It will automatically rebase the PRs on top of each other, so we don’t have to do it manually. Given the following commit structure, presented by calling the command: sl sl
  @  00f1749f6  30 minutes ago  oliver
  │  implement user signup
  │
  @  e0dbbc80e  50 minutes ago  oliver
  │  implement email package
  │
  o  4f6928029  Yesterday at   oliver
╭─╯  update cache package
│
o  876f46044  Today at 07:45  remote/main The workflow with sapling will be: sl goto 00f1749f6              # checkout the sign up code
vim features/signup/signup.go  # make changes to signup
vim lib/email/email.go         # make changes to email package

sl absorb                      # magic 👻 With only a single command , sapling will: sl absorb Amend the changes to the email commit. email.go Amend the changes to the signup commit. signup.go Rebase the signup commit on top of the email commit. Your changes will be absorbed into the PRs, and the PRs will be rebased on top of each other. You don’t have to do it manually as before. With only a single command. Well done! 👻 My experience with sapling I’m using sapling for a few weeks now. It’s a new tool, so there are some problems, but the overall experience is great. Commonly used commands View repository status: : show the commit-graph (or smart-log) sl : show the status of the current branch sl status Moving between commits: : checkout the commit. sl goto <commit> , : checkout the next/previous commit. sl next sl prev Working with commits: , , : add/remove/untrack files. sl add sl remove sl forget : commit the changes as a new commit. sl commit : edit the commit message. sl metaedit : absorb the changes into the PRs, and rebase the PRs on top of each other. sl absorb : rebase the PRs on top of each other. sl rebase While adds all changes to the staging area, including new files, deleted files; the corresponding command will only add new files to the staging area. To remove files, we must use . This will be a bit annoying when committing vendor files, since we have to list all deleted files to remove them. I’m not sure if there is a better way: git add sl add sl remove $ sl status

? vendor/github.com/sample/cache/v2/caching.go
? vendor/github.com/sample/cache/v2/stripe.go
! vendor/github.com/sample/cache/v1/deprecated.go
! vendor/github.com/sample/cache/v1/formatter.go $ sl add vendor

A vendor/github.com/sample/cache/v2/caching.go
A vendor/github.com/sample/cache/v2/stripe.go
! vendor/github.com/sample/cache/v1/deprecated.go
! vendor/github.com/sample/cache/v1/formatter.go # Have to list all deleted files to remove, is there a better way? 😞
$ sl remove vendor/github.com/sample/cache/v1/deprecated.go \
            vendor/github.com/sample/cache/v1/formatter.go

A vendor/github.com/sample/cache/v2/caching.go
A vendor/github.com/sample/cache/v2/stripe.go
R vendor/github.com/sample/cache/v1/deprecated.go
R vendor/github.com/sample/cache/v1/formatter.go Pushing PRs to GitHub Sapling provides 2 ways of pushing PRs to GitHub: and . Each has different trade-offs. I prefer using the command: sl pr sl ghstack sl pr It creates a PR for each commit. It pushes the PRs to GitHub in the order of the commits. It’s easier to understand as commits stacks nicely on each other. It works well and can be reviewed with GitHub’s UI. Another benefit, it does not require write permission to the repository, in case you do a fork. The command creates a more complex web of PRs. And there are a lot of times when it fails to push the PRs. Try again won’t work. No available fixes. Have to duplicate these PRs again and risk spamming my company repositories. I don’t recommend it. sl ghstack Reviewing PRs Sapling recommends using for reviewing. But I find it slow, less responsive, and sometimes gives wrong file changes. I prefer using GitHub’s UI. When pushing PRs with , it creates a single commit for each PR. So the reviewer can open the latest commit, and review the changes. Just one more extra click compared to the usual review flow: reviewstack sl pr Go to Commits tab. Choose the latest commit. Review and add comments. These comments will appear on the PR as usual. Other things It requires cloning a new repository, so you can’t use your familiar git commands. It won’t work with your existing tools, IDE, etc. You have to use the UI to view changes. sl web Give it a try! Sapling is great. While there are a few troubles, and it requires a small learning curve, it pays back in the end. Stacking, pushing, and reviewing PRs is much easier. Give it a try! __ Also published . here

Experimenting With Sapling, the New Git Client From Meta

In Search For Future Crypto Trends

En busca de futuras tendencias criptográficas

À la recherche des futures tendances cryptographiques

फ्यूचर क्रिप्टो ट्रेंड्स की खोज में

将来の暗号トレンドを求めて

Em busca de futuras tendências criptográficas

Tìm kiếm xu hướng tiền điện tử trong tương lai

寻找未来的加密货币趋势

GM. It's Crypto Player One, the first and only daily newsletter on crypto gaming. We are the MrBeast of web3 gaming newsletters cuz we are off the charts. Here's what we've got for you today: Daily Trivia. Four blockchain gaming lessons from Q3. In Other News. Daily Trivia Which female video game hero is known for its attractive figure? Scroll down to find out the answer. Four Blockchain Gaming Lessons from Q3 Our friends at Naavik released a report on the state of blockchain gaming in collaboration with Coinmarketcap. Here's what we learned: We still have some way to go before mass adoption. According to DappRadar, there are less than 2000 blockchain games and only 1 million unique active wallets. Compare this to the countless video games you can access on the Google Play Store and the App Store. The third generation of crypto games is coming. CryptoKitties defined the first era, showing what NFTs and in-game ownership can look like. But it didn't succeed due to Ethereum's lack of scalability. Axie Infinity was the star game of the second (play-to-earn) era. But its poor economic design, which attracted more hustlers than traditional players, was doomed to fail. So the third era of blockchain gaming is taking lessons from the previous generations, prioritizing the gameplay instead of the earning potential of the game. The distribution is getting better. The Epic Games Store has hosted a ton of web3 games like Blankos Block Party, Superior, and Star Atlas. Apple allowed the sale of NFTs, although charging 30% of each sale. But the good thing is that now the mainstream gamer can access web3 games. The future is free-to-own After the Play-to-Earn, Play-and-Earn, and Play-and-Own, the new meta is Free-to-Own. It's better than all previous versions because it lowers the barrier to entry by offering free NFTs without gating the gaming experience. It seems like the best model that will accelerate mainstream adoption. If you're interested, you can read the full report here. In Other News Revolut's new chat feature will integrate NFT profile pics. The creators of Final Fantasy have revealed their first NFT game. Answer Lara Croft. Funny enough, a coding error led to Lara Croft's large bosom. And boy, are we happy with that mistake? Want to Stay On Top of All Things Crypto Gaming and NFTs? Sign up for the daily newsletter - it’s free! Photo by on Lorenzo Herrera Unsplash

🎮 What We Learned About Blockchain Gaming in Q3 👀

Prologue In my experience, I learned that skipping the basics and proceeding all along to the application of certain technologies (such as programming language) to create something that could make sense is hard. Missing the basics also could lead to a lack of foundation which is a building block of intermediate to advanced concepts. Sure, learning by doing is great for some people but skipping the starting notions in order to start something out is also an important thing worth looking at. In this part, I will talk about the core concepts of programming. That is what are variables alongside their data types, different types of operators in programming, kinds of structures crucial for grouping our source code, and other basics. I will share fundamental concepts of programming by making them simple and concise over the hood just to make things more brain-friendly. These are the fundamental building blocks that must give emphasized first to everyone who is just getting started on learning how to code. And without further ado, let's get started. Foreword This material is not a stand-alone reading to learn about the fundamentals of programming as a whole. It is a simplified blog that tackles the basics. It could be used as a primary or secondary reference for learning them but it's not a stand-alone one. You could use this with other means of learning such as watching a video, reading other articles, etc. It's good to be supplemented with third-party references. You can also use this to have a quick read about concepts in relatively simplified content. If you are just starting out, it really doesn't matter to learn all the internal happenings about specific concepts. What really matters is that we know their use cases and we know at least how their work. It's not necessary to immediately learn their total workings in the background. But if you want, you can explore them on your own as there are tons of references on the web to make your hands dirty with it if you want to play with it. After all, we are different types of learners and nothing's wrong with that. Studying the fundamentals of programming is also not language-specific. In fact, it is a general concept which means that we can use other programming languages out there when learning it. I suggest you pick those languages that are very popular in the tech industry such as Java, Python, JavaScipt, Rust, Go, etc. These languages are well-established ones that also have a bright future on top of them. In regards to their setup and installation to get started on your computer, the web is full of tutorials on these. Feel free to search them out to get your hands dirty in no time. Variables What the heck are these variables and why they are important in programming? Variables in programming and in mathematics are similar. They basically just store a value that could be used for different crucial operations. But unlike in mathematics, variables could store not just numbers. They could be characters, series of characters (or called strings in programming), booleans (just only true or false), and any other that could be stored for further operations. thing Variables could also store references to a specific or in programming. Such references mean that variables hold the information crucial for accessing them. Values are also called or just simply data in some contexts. thing entity entity's literal Under the hood, it's also important to note that variable values are stored in the memory of a computer they are running from just like other things in programming. Simple variable declarations in Python myFullName = "John Rommel Octaviano"  
myMiddleInitial = 'P';  
myAge = 20;  
isHuman = true; Accessing or reading the values that a variable stored could be used for different operations such as multiplication and division if the said value is a number. The same goes for strings. We can do string manipulation (or just basically modification) like converting them to uppercase. Storing values in a variable is one of the often practices that we must fully and properly be utilizing of. Storing and retrieving values should also use moderately. In some instances, the usage of variables is not necessary at all. In fact, we can still do some operations to do our aimed task. But variables make these operations much easier by reducing repetitions like duplicating code. Variables are also crucial in operations where values need to be stored in order to achieve a specific operation to keep track of something which then the result of it that is stored in that variable and is also to be used for further operations, and so on. A source code for solving the roots of a quadratic equation that shows the importance of variables in storing values in such small use cases double a;  
double b;  
double c;  
double determinant;  
double root1;  
double root2;  
  
a = 2.3;  
b = 4;  
c = 5.6;  
determinant = b * b - 4 * a * c;  
  
if (determinant > 0) {  
  root1 = (-b + Math.sqrt(determinant)) / (2 * a);  
  root2 = (-b - Math.sqrt(determinant)) / (2 * a);  
} else if (determinant == 0) {  
  root1 = root2 = -b / (2 * a);  
} else {  
  double real = -b / (2 * a);  
  double imaginary = Math.sqrt(-determinant) / (2 * a);  
} Constants Constants are just special types of variables that cannot be updated or prohibited from changing once we declared them. Since these variables cannot be changed, operators like Assignments and Increment/Decrement will not work, and using them with constants could lead to errors. They are only available for reading or accessing their value for specific purposes. It's also just a programming representation of absolute variables in Math like the Pi, Golden ratio, Euler's number, and many more. Identifiers Identifiers are just another term for of something in our code. In programming, most concepts like variables, functions, objects, arrays, and others are needed to become known by putting names. the name Such names that we created are used for their references and specific purposes when we need to interact with them like creating, reading, and updating their values. Conventionally, identifiers must become readable like putting a concise name in relation to their value. They must also a valid by following a specific language's official syntax just like not using a reserved keyword. I highly suggest that we must check the language syntax for creating identifiers when creating one to avoid errors. Conventions like PascalCase, camelCase, and kebab-case are the most commons to use. Data Types Since variables could store values like strings, numbers, and booleans, these variables could also be regulated on what type of data or literal they could store. In static languages like Java & C#, stating data types in variables is highly enforced upon declaration. Not doing so could cause exceptions. Simple statements using C# that declare variables with data types string myFullName = "John Rommel Octaviano";  
char myMiddleInitial = 'P';  
int myAge = 20;  
bool isHuman = true; On the side of dynamic languages like JavaScript and Python, stating data types are not necessary. The compiler (or basically just an application that converts our code into a series of 0s and 1s that only our CPU understands to execute our desired operations) is not enforcing these kinds of declarations (or basically just creating but not storing anything). Simple statements using Python that declare variables without data types myFullName = "John Rommel Octaviano"  
myMiddleInitial = 'P'  
myAge = 28  
isHuman = true Just think of data types like just a marking that states that a particular variable could only accept a value depending on the data type that is stated. Not following these markings by means of not storing a number in a String could cause errors. A protocol must be followed. - for integers of the whole number int - for numbers that have a floating point value float - for numbers that have floating point value in which the range or limit of this data type that a variable can accept is much higher than the float double - for integers of the whole number in which the range or limit of this data type that a variable can accept is much higher than int long - for a single character char - for the sequence of characters String - for values true or false boolean Simple statements using Java that declare variables with data types String myFullName = "John Rommel Octaviano";
char myMiddleInitial = 'P';
int myAge = 20;
float myBatteryLevel = 90;
double myTemperature = 35.7;
long myCellCount = 30,000,000,000,000;
boolean isHuman = true; and many more. These are the common and general types that most programming languages present particularly the strongly-ones. There are also data types for specific entities like arrays (basic storage for values), and many more. In fact, we could also create our own types (this is called in programming, an advanced concept). Generics Simple (Primitive) and Composite (Reference) Variables have also kinds of their own. It could be simple or composite. A variable could be considered as simple if the data type that is used to create or declare it is using built-in data types. Those are types that are naturally provided by the language itself. Simple types are also called which used primitive data types of a specific language. Basically, they directly stored the actual value. In which, a simple or primitive variable literally represents the actual literal itself. primitives Meanwhile, composite ones are basically just the complete opposite. Those are the variables that used created types by the programmer itself. In most languages, we can create our own types. They are also called types. reference Reference variables commonly do not directly store the actual value itself but the or just basically a piece of information of the actual value's location in the memory. reference It's a kind of intermediate topic but as your progress succeeds, you will know more about them and their importance in writing code. Operators Storing different values and literal is good. But we need to do something about them in order to consume or use them depending on the specific use case that we aim for. Good thing is, just like in Mathematics, there are operators. Fundamental operators in mathematics and some programming operators shared concepts between them. These are the general operators which are generally common across different PLs (programming languages) out there. Some operators could also mean different in other language syntaxes for unique operations. They are also part of their own unique features. Arithmetic Addition operator (+) add number types. It could also be used to concatenate (or just basically just combine) non-string types to string types in most languages. Subtraction operator (Subtract) (-) subtract number types. It could also use to indicate negative numerical. Multiplication operator (*) multiply number types. Division operator (/) divide number types. Modulo operator (%) it computes the remainder of the number types. Simple statements using JavaScript that perform different basic computations and store their values on different variables let numOne = 23;  
let numTwo = 24;  
let sum;  
let difference;  
let product;  
let quotient;  
let remainder;  
  
sum = numOne + numTwo; // 47
difference = numOne - numTwo; // -1
product = numOne * numTwo; // 552
quotient = numOne / numTwo; // 0.95833333333
remainder = numOne % numTwo; // 0 Logical AND (&&) returns true if both the on the left and right are true conditions OR (||) returns true if at least one on either left or right is true condition NOT (!) flips the boolean value of a or a value condition Simple statements using Java that perform different basic operations by using logical operators between 2 boolean values and printing their results boolean booleanOne = true;  
boolean booleanTwo = false;  
  
System.out.println(booleanOne && booleanTwo); // false  
System.out.println(booleanOne || booleanTwo); // true  
System.out.println(!booleanOne); // false  
System.out.println(!booleanTwo); // true Relational Equals to (==) returns true if both or value are equal condition Not equals to (!=) returns true if both or value are not equal condition Greater than (>) returns true if the value on the left is bigger than the right ** Less than (<)** returns true if the value on the left is smaller than the right Greater than or equal to (>=) returns true if the value on the left is bigger than or equal to the right Less than or equal to (<=) returns true if the value on the left is smaller than or equal to the right Simple statements using Python that perform different basic comparisons of numbers by using relational operators between integer numbers and printing their results numOne = 56
numTwo = 33

print(numOne > numTwo) # True
print(numOne != numTwo) # True
print(numOne > numTwo) # True
print(numOne < numTwo) # False
print(numOne >= numTwo) # True
print(numOne <= numTwo) # False Assignment Assignment (=) assigns the value of the right variable to the left variable Add and assign (+=) increase by adding the value of the left variable from the right variable Subtract and assign (-=) decrease by adding the value of the left variable from the right variable Multiply and assign (*=) increase by multiplying the value of the left variable by the right variable Divide and assign (/=) decrease by dividing the value of the left variable from the right variable Simple statements using C++ that perform different basic comparisons of a number by using assignment operators and printing its final result int numOne = 28;

numOne += 5; // 33
numOne -= 4; // 29
numOne *= 7; // 203
numOne /= 2; // 101

cout << numOne; // 101 Increment/Decrement Post-increment (x++) increase the value of the variable by 1 after using the value Pre-increment (++x) increase the value of the variable by 1 before using the value Post-decrement (x--) decrease the value of the variable by 1 after using the value Pre-increment (--x) decrease the value of the variable by 1 before using the value Simple statements using Java that perform different basic modifications of a number by using increment/decrement operators and printing its final result int numOne = 28;

numOne++; // 28
++numOne; // 30
numOne--; // 30
--numOne; // 28

System.out.println(numOne); // 28 Control Structures Writing code with operators and variables is relativity good enough for selected operations. But most of the time, we need additional tools to meet certain functionalities that our app needs. We need more tools to perform tasks that can do the heavy lifting for us in meeting our specific needs in code. And this is where in programming came to work. They are crucial and not just optional tools to consider. Just like operators, there are structures that are not present in one language and that is part of learning some adjustments when jumping from one language to another. control structures But, the good thing is there are general structures that most languages are common for. Selection Serves as a on what code will be run. Since it's like a , the only way to open them is to have a true , literally. Or a condition evaluates to TRUE. gate gate key Single Alternative (if) Statements will be done or executed when a is met, evaluated, or equal to TRUE. Otherwise, meaning if the condition will become equal to FALSE, then nothing happens. condition An if statement checks if the value of a variable is equal to something through a conditional in JavaScript, in which if the checking is true, it will print something, otherwise, nothing happens let foo = "foo";  
  
if(foo === "foo") {  
  console.log("foo!"); // Prints this if true
} Double Alternatives (if-else) Statements will be done or executed when a condition is met, evaluated, or equal to TRUE. Otherwise, meaning if the condition will become equal to FALSE, then the alternative statements will be executed. An if statement checks if the value of a variable is equal to something through a conditional in JavaScript, in which if the checking is true, it will print something, otherwise, it prints something else let foo = "foo";  
  
if(foo === "foo") {  
  console.log("foo!"); // Prints this if true
} else {  
  console.log("bar!"); // Prints this if false instead
} Multiple Alternatives (if-elseif-else) Statements will be done or executed when a condition is met, evaluated, or equal to TRUE. But, if the condition returns FALSE, succeeding conditions will be checked until a condition is evaluated to TRUE, and statements inside of that will be executed. Finally, if all those succeeding conditions are all evaluated to FALSE, meaning none of them happens, then the statements in the final block will be executed. An if statement checks if the value of a variable is equal to something through a conditional in JavaScript, in which if the checking on the first condition is true, it will print something, otherwise, it will check the next conditions and print something else if true but if all conditions are false, print the last one if(foo === "bar") {  
  console.log("bar!"); // Prints this if true
} else if(foo === "foobar") {  
  console.log("foobar!"); // Prints this if false instead
} else {  
  console.log("foo!"); // Prints this if everything else is false
} Repetition Serves as a that continues to spin or run our code repeatedly. Since it's like a , the only way to stop them is to have a false , literally. Or until a condition returns FALSE. wheel wheel handbrake Repeat-While (while) Before statements will be run, a condition is first evaluated and if the result is equal to TRUE, code will be run. After the execution, it will back at checking the condition again and it will run again and again until the condition becomes FALSE. A basic while loop in Java that prints all numbers within the starting and ending range int counter = 1;  
  
while (counter <= 10) {  
  System.out.println(counter);  
  counter++;  
} Do-Repeat-While (do-while) Statements will be run first before checking the condition. After checking and the result was TRUE, it will run again the code and back at checking again. It will run again and again until the condition becomes FALSE. Unlike while loops, do-whiles are expected to run at least once. A basic do-while loop in Java that prints all numbers within the starting and ending range do {  
  System.out.println(counter);  
  counter++;  
} while(counter <= 10); Repeat-For (for) This structure also works under the hood like while loop but they have their own major difference. In for loop, iteration or number of times the code will run is known before the execution while the iteration is not known in a while loop. The code in here will run on a known time while the while loop is not. The other differences are most commonly language specific. A basic for loop in Java that prints all numbers within the starting and ending range for(int counter = 1; counter <= 10; counter++) {  
  System.out.println(counter);  
} Epilogue And there you have it. That's some of the different concepts of programming categorized as fundamental. We tackled variables alongside what constants, and identifiers are, alongside data types and their subtypes for basically just storing variables. We also learned more about different operators from arithmetic to increments and decrements to solve create calculations and execute crucial tasks. Lastly, we also talked about different control structures that make our applications much more smarter. I hope you learn more about the basics of programming. Now, you have at least basic ideas about some general concepts in relation to programming at least in simple terms. Concepts that are fundamentally crucial in making real-world applications. Feel free to learn more about them as your progress grow. Thank you and see you at the next one. Recipes tell you nothing. Learning techniques is the key. Tom Colicchio

Understanding Programming Fundamentals: Variables, Operators, Control Structures

They say, once you come to Georgia, you find yourself reluctant to leave. This stunning country – particularly attractive with sunny weather, scenic mountains, and of course, exceptional wine – has not only incredible nature and rich culture, but also all chances to become another cradle of fintech and blockchain. In 2020, Georgia 7 among 190 economies in the ease of doing business, which made over 50,000 tech specialists relocate here during the last couple of years. What’s far more exciting is that the Georgian government has a good attitude toward cryptocurrencies, and is already hard at work on a legal framework to support mass adoption. was ranked Today, thousands of crypto freelancers are working internationally from Georgia, and it’s therefore not surprising that Tbilisi finally became one more meeting point for investors, C-level executives, developers, and creators involved in Web3. They all flocked to , the first-ever international Web3 conference in the Caucasian region, on October 22-23. Presented to the wide audience as a combination of GameFi and DeFi, the event boasted a total of 8-panel discussions on its business agenda, over 70 speakers and industry experts as well as 50+ sponsors and exhibitors showcasing their innovative products. DeGameFi In this article, I’ll provide a deep look into what happened throughout these two days at the Sheraton Grand Metechi Palace hotel and highlight the most insightful events. Let’s buckle up! Overview of DeGameFi DeGameFi is the first Georgian community-based company with a goal of bridging the worlds of Web2 and Web3. DeGameFi’s team started with a monthly series of gatherings, such as meet-ups, hackathons, and workshops, aimed at popularizing blockchain technologies and helping traditional businesses transit to the new era of finance. And now, thanks to the growing interest in cryptocurrencies among Georgian companies and institutions, DeGameFi has grown to a large-scale conference attended by over 1,000 Web3 enthusiasts from different regions. Source: Twitter Combining the most engaging formats and activities for networking and knowledge sharing, the event offered to visit 6 main sections so that each participant could fully immerse into the Web3 environment: Conference hall; Exhibition floor for business; Tech room; NFT gallery; Start-up competition; VIP area. Apart from that, there were various gatherings, workshops, contests, and tech talks available during the conference. No matter whether you are a VC, entrepreneur, developer or artist, here you would find many promising opportunities and projects for mutual cooperation. Fun fact: DeGameFi even invited community members to join the conference online at the Decentraland. At DeGameFi, I caught up with a few fellows who I asked to share their impressions of the event. Among them were Konstantin Gorin, Head of Support at and , Elena Shiltseva, CPO at , as well as Mike Ermolaev and Gennadii Bazhukov from . They all agreed that the conference was organized at a very good level and laid the groundwork for a brand-new way of interaction between crypto supporters in Georgia and the CIS. Cryptopay NearPay Roketo Business Kikimora Labs “The Covid-19 pandemic and the ongoing international upheavals made us almost forget this wonderful atmosphere of face-to-face meetings where the most innovative ideas are born. DeGameFi reminded us how vital the offline events are in the crypto industry and the scale of the conference ideally suited to the establishment of fruitful connections,” notes Konstantin Gorin. Source: Twitter “It was really great to meet so many local guys at DeGameFi. Even the Bank of Georgia got on board and showcased its Web3 projects, which demonstrates that the technology is here to stay and regulators are keeping their hands on the pulse. The Georgian crypto community is developing at a rapid pace, and the conference has proven it true,” adds Elena Shiltseva. Gennadii, in charge of Business Development of Kikimora Labs, was struck with the geography of participating companies and individuals: “We ran into attendees not only from Georgia, but also from the USA, Great Britain, South Korea, and China. I’d like to separately note that the venue was selected perfectly, which contributed significantly to effective networking. I, personally, partnered with a few investors and found some interesting projects that are worth attention.” Mike, who is Head of PR & Content at Kikimora Labs, was impressed by the various interactives related to GameFi. “The NFT gallery was a wrap! An amazing place for artists to catch some inspiration, and I think that even those who still feel skeptical about NFTs couldn’t remain indifferent. Besides, the presence of brands promoting gamification was huge. The participants were welcomed to try various activities like playing blockchain-based games with underlying NFT economics to assess the potential themselves,” he shares. Source: Twitter But what really wowed everyone is the high quality of expert content delivered on the main stage and a stir around panel discussions devoted to trending topics in Web3. So let’s get to it. Speaker Lineup And Panels The two-day agenda was tailored to ingesting insights from multiple directions of the DeFi development: from crypto payments and decentralized marketplaces to metaverses, Web3 investment strategies and marketing specifics. Source: DeGameFi.io DeGameFi brought on stage the best and the brightest minds from both Georgia and global markets, including: Mikheil Didebulidze, partner at VNTR Capital, founder of DeGameFi; Tone Vays, analyst, derivatives trader, influencer and event producer; Levan Kobakhidze, CDO at Bank of Georgia; Max Krupyshev, CEO CoinsPaid & ; Cryptoprocessing.com Iouri Galitchenko, strategic partnership Binance Pay&Card; Colin Donohue, director of Startup Connect & Startup Grind; Eralp Hatipoglu, co-founder & CEO at CityPay, and more. “The quality of dialogue between the keynote experts and attendees was excellent. I was pleasantly surprised by a high level of speakers who shared their comprehensive views on the current Web3 trends and challenges. This once again demonstrated that Georgia as a crypto hub is full of forward-thinking individuals and entities,” says Gennadii Bazhukov. A peculiar feature of DeGameFi was a number of panel discussions featuring the most pressing issues that the DeFi and Web3 industry is facing today. I’d like to point out those panels that, from my point of view, were the hottest and the most buzzing. Web 3.0 payments from past to present: how are traditional banks keeping up? - Panel : George Gvazava (CryptX), Levan Kobakhidze (Bank of Georgia), Iouri Galitchenko (Binance Pay & Card), Eralp Hatipoglu (CityPay), Max Krupyshev (CoinsPaid) : Max Novak from MyNearWallet : The impact of regulations on the DeFi ecosystem; the prospects of CBDCs and stablecoins; the latest efforts to bridge banks and crypto made by payment giants like Mastercard; tokenization and interoperability; obstacles to mainstream adoption of DeFi; Web3 for businesses; metaverses and what banks can offer in this visual world. Panel: Web 3.0 payments from past to present: how are traditional banks keeping up? Experts Moderator Topics : David Chikhladze (OWNIC), Zeshan Ahmad (P360), Michael Holden (Maxihaxi) : Konstantin Gorin from NearPay and Cryptopay Panel: Sports 3.0 - new era for sports entities Experts Moderator : The driving force behind Web3 initiatives in sport; crowd communication models; integrating blockchain and web3 technologies to sports – collaboration or rivalry; engaging huge fan bases and adoption issues. Topics Sports 3.0 - new era for sports entities - Panel : Manuel Rensink (Fathom Protocol), Ioseb Bolqvadze ( , & OneSoft), Lasha Antadze (Rarify) : Maria Reshetnik from : Current and potential barriers to DeFi prosperity; emerging trends; risks posed by tightening regulations; the convergence between DeFi and TradFi; the most pressing real-life use cases that DeFi can bring. Panel: The evolution and the future of DeFi Experts Cryptal.com Cryptomat.com Moderator FutureComes Topics : Amirsan Roberto (Sinofy Group), Kirill Mishanin (Infodriver Capital), Vojta Rocek (Presto Ventures), Sergi Gvarjaladze (Kettari Foundation), Gvantsa Baidoshvili (Revenue Capital) : Maria Reshetnik from FutureComes : Investment trends and strategies in the crypto/blockchain segment; red flags during the investment process; investing in DAOs – pros and cons. Panel: A VC's guide: institutional decentralization and investments Experts Moderator Topics : Mikheil Didebulidze (VNTR Capital), Eralp Hatipoglu (CityPay), Colin Donohue (Startup Connect & Startup Grind), Levan Khomeriki (Two Point Zero) : Mike Ermolaev from Kikimora Labs : The reasons for decline of Web3 startup funding; the most popular areas of investment; the pitfalls of investing in the play-to-earn projects and metaverses; leading countries in Web3; investment DAOs; the role of crypto marketing in 2022-2023; the legitimacy of Web3. Panel: Web3 start-up ecosystem: current state Experts Moderator Topics Mike Ermolaev and Colin Donohue “The DeGameFi panels were always full houses. I moderated the discussion that was devoted to the Web3 start-up ecosystem and it definitely collected more than a hundred of viewers. The hall was packed; every seat was occupied and people had to stand behind. Unbelievable!” comments Mike Ermolaev. Tech Room, Afterparty And Side Events The agenda of the tech room, also positioned as an additional educational space, was focused more on technology-oriented speeches and presentations of infrastructure solutions. Elena Shiltseva who commanded the scene there shares her feedback on the host experience: “Except for participating at DeGameFi as a speaker of the main stage where I talked about the role of a CFO in the process of transiting from Web2 to Web3, I had a great pleasure to host the tech room section. The key benefit of this role was greeting many talented people in the blockchain industry on stage and gaining maximum knowledge about innovations that are emerging in this field. I’m still thrilled by the atmosphere, and of course, I’d like to say massive thanks to the organizers who made my job of hosting super easy!” Elena Shiltseva hosting the tech room section Elena also shared with me her own shortlist of the top 4 speakers who rocked the tech room with their valuable and fundamental reports. First, she mentioned Max Sultakov, CEO of Mover, who talked about technical and economic aspects of going cross-chain on high-performance L1s. Then Elena proceeded to Vladimir Prosvirkin, founder of Aspis, who explained why DAOs will replace legal entities and how to create a successful decentralized autonomous organization. Her other favorite was Avtandil Kutchava with a practical report on crypto regulations in Europe and Georgia. And finally, she got inspired by the speech of charismatic Alexander Wendt from Trend Vision who showed with real examples, why high-quality PR efforts are essential for start-ups and how not to fail when putting them into practice. “These were amazing applied reports, the perfect examples of how tech-related speeches should be prepared and presented,” Elena concludes. Today’s events cannot do without entertainment, thus maintaining the perfect balance between work and pleasure. DeGameFi partnered with the world’s biggest Web3 conference WOW Summit to give 100+ VIP ticket holders unforgettable emotions and exclusive networking opportunities at the end of the event. The afterparty took place at Axis Tower's Sky Bar where representatives of the international and local funds, CEOs of the most promising projects, and local state institutions enjoyed music, fine drinks, snacks, and enchanting panoramic views over the night Tbilisi. DeGameFi x WOW Summit Afterparty The list of side events also included VIP dinner and investor’s breakfast, sponsored by Kikimora Labs. The latter gathered together a few dozen people who are involved in the most promising niches, such as SpaceTech, or look for tech innovations to co-invest in, particularly on the Georgian market. “We connected with the global Web3 community, made a lot of networking pics and really had fun attending both the investor’s breakfast and the afterparty. The beauty of these events lies in their exclusive status that ensures the presence of your target audience, reliable partnerships and fantastic experience sharing. And let’s face it, talking business is much more enjoyable when getting together either over coffee or drinks,” says Mike Ermolaev laughing. Final Thoughts Driven by the mission to support the growth of the crypto community in Georgia, DeGameFi took the first step towards bridging traditional business and Web 3 in a solid and transparent way. Given that the country is currently in the process of making itself a fintech and crypto hub, the events under the DeGameFi brand will most likely become annual and will honor the progress achieved with attempts to foster blockchain adoption en masse.

DeGameFi Conference in Tbilisi: Introducing a New Crypto Hub to the Web3 Community

Over the past couple of years, several smart-contract capable platforms have emerged in the crypto space. Known for its swiftness and affordability, the NEAR protocol competes with similar projects as it aims to address the limitations of older, rival systems. is a layer-1 blockchain solution designed specifically for creators. The platform presents itself as a base layer or foundation for developers to build and launch innovative decentralized applications. Indeed, NEAR employs the more efficient proof-of-stake consensus mechanism and prioritizes ease-of-use, interoperability, and scalability in addition to being a community-driven platform. NEAR Since its emergence NEAR has grown into a thriving blockchain ecosystem. At writing, the platform hosts over 500 DeFi projects that offer novel, real-world applications. Here’s a list of 15 successful DApp projects available on the NEAR ecosystem. Ref Finance Currently the foremost DeFi project on the NEAR protocol, is a multipurpose platform with services revolving around the network’s native NEAR token. It is notably an automated market maker DEX. This means the platform facilitates the permissionless exchange of assets via liquidity pools. Ref Finance Likewise, Ref Finance provides users with access to a robust suite of DeFi offerings. These include a lending protocol, yield farm, stableswap platform, synthetic asset issuer, and more. With staking and farming features, users get to earn the platform’s native currency Ref, which they can use to earn more funds or participate in the governance of the community-led platform. Amongst other perks, Ref Finance is also known for its high rewards, low fees, high-speed operations, and security, which are all benefits of the underlying NEAR protocol. It also leverages NEAR to provide multiple pools-in-one contracts, atomic transactions, and customizable pool fees. The platform was founded in 2021 by NEAR co-founder, Ilia Polosukhin. Aurora Launched in May 2021, is a thriving Ethereum Virtual Machine built on the NEAR protocol. The layer-2 scaling solution exists to provide Ethereum compatibility to DApps on NEAR. Aurora is unarguably one of the most important projects the NEAR network hosts. It offers developers the Ethereum 1.0 experience, allowing them to write smart contracts in Solidity while still enjoying the benefits of the NEAR network. Aurora Like many other NEAR DApps, Aurora takes advantage of the protocol’s high throughput, speed scalability, and low transaction costs to create a great user experience. With the Aurora Bridge (working in tandem with the NEAR Rainbow Bridge) users can carry out the trustless transfer of ETH and ERC20 tokens between Ethereum and Aurora. The network is governed by a decentralized autonomous organization called the AuroraDAO. MyNearWallet One of the most popular NEAR wallets, is a non-custodial wallet for the NEAR blockchain. Users can securely store NEAR tokens and other assets that are compatible with the layer-1 network. MyNearWallet is available on the web and on mobile devices soon, and it can be connected to a hardware wallet for added security. Since the wallet is non-custodial, the user has full control over its private keys, and therefore the funds. MyNearWallet wNEAR, NFTs and various assets across the NEAR ecosystem. MyNearWallet supports Rainbow Bridge A crucial part of the NEAR ecosystem, as the name denotes is a bridge that facilitates the seamless transfer of assets between the NEAR and Ethereum networks. With the Rainbow Bridge, developers can transfer several well-known ERC-20 tokens between Ethereum and NEAR wallets or projects. Users migrating assets to NEAR gain access to the network’s developer-optimized environment with its one-to-second transaction times, affordable fees, and relatively low bridge-transfer costs. the Rainbow Bridge The Rainbow Bridge is the only fully decentralized, permissionless, and trustless bridge linking blockchains. Users do not have to rely on the protocol itself, rather they only need to trust the security of the networks it connects. CoinPipe is a payment solution that runs on the NEAR blockchain. The platform provides tools for crypto operations, including crypto POS terminals, for e-commerce and offline retailers alike. Business owners are able to manage their treasury and invoices easily through a user-friendly dashboard. CoinPipe employs the NEAR blockchain for its speed, security, and low-cost transactions. CoinPipe NearPay One of the most important products on the list, is a payments platform on the NEAR network that works to bridge the gap between crypto and fiat spaces. Some of NearPay’s products include the NearPay Wallet and the NearPay Card, the NEAR ecosystem’s first-ever debit card. NearPay The NearPay Wallet already supports a notable range of digital currencies and is available for web, IOS, and Android users. Meanwhile, NearPay is available as a virtual debit card (and soon as a physical card). Users can track their spending, manage their pins, and freeze/unfreeze their cards among a slew of other features still in the works. As part of its offerings, NearPay's crypto on-ramp widget enables businesses to accept fiat payments from customers instantly converted into a variety of supported crypto assets. Roketo is a NEAR-based platform that uses persistent, time-distributed transfers to boost token utility, and includes Roketo Business, an app designed to streamline financial and operational aspects of Web3 businesses (such as salaries, grant allocation, etc). It also offers a payment widget, airdrop solutions, and subscription tools for Web3 services, including NFT subscriptions. It can be used for token vesting, play-to-earn activities, and token streaming, among other things. Existing on the NEAR blockchain allows Roketo to charge low commissions and offer lightning-fast transactions. Roketo Burrow is a decentralized, non-custodial interest rate market protocol that runs on the NEAR blockchain. The platform retains NEAR’s user-friendly nature and allows users to supply and borrow assets to earn interest and unlock liquidity. The basis of Burrow’s services are interest-bearing assets such as staked Near (stNEAR) or other staked derivatives such as wBTC, or stETH. Burrow specifically uses interest-bearing assets of base layers to unlock yields from the base layer as these provide the most secure rates as well as the highest returns. Users can deposit these assets on the platform to earn an attractive yield and also take out self-paying loans, which entails borrowing against future interest. Burrow Decentral Bank is a DAO that focuses on the development, support, and issuance of NEAR-native stablecoins. The goal is to create an easy-to-use, “truly stable” stablecoin that can weather unfavorable market conditions. Notably, Decentral bank has successfully released the first of these assets, a stablecoin built on the NEAR protocol dubbed $USN. Decentral Bank manages the smart contracts of $USN and its Reserve Fund. The DAO also votes on key decisions surrounding the stablecoin. Decentral Bank Octopus Network is a NEAR-based cross-chain network that allows developers to launch and run application-specific blockchains known as appchains. With Octopus, creators can get flexible and cost-effective security for their app chains in addition to multichain functionality, and on-chain governance. The team behind the project took inspiration for the network from the Octopus. Each Substrate-based, EVM-compatible appchain is self-sustaining and can adapt to evolving environments. However, when joined as a whole, the Octopus network is beneficial to all members of what the team describes as an “internet of blockchains.” Octopus Network Band Protocol is a decentralized, cross-chain data oracle platform that aggregates real-world data and APIsonto smart contracts. The protocol serves as an intermediary between blockchain-based DApps and legacy internet data sources. Band integrated with the NEAR network over a year ago to bring its services to creators within the ecosystem. Developers can easily receive off-chain data for their applications or projects. In turn, Band Protocol leverages NEAR’s features to increase throughput and scalability. Band Protocol Paras is the most popular NFT marketplace within the NEAR ecosystem. Paras initially began with digital art cards inspired by real-world trading cards but later diversified its offerings. Interestingly, the platform approaches the non-fungible token industry with a curatorial mindset. In addition to encouraging a variety of styles among its creators, Paras emphasizes quality over quantity and only publishes themed collections. As it is built on the NEAR blockchain, the platform charges extremely low fees even as it grants users a unique NFT experience. Paras Alchemy Pay is a hybrid payments solutions provider that pushes blockchain adoption for merchant networks, developers, and financial institutions. The platform opens the door for fiat users to easily access crypto assets and services easily accessible to fiat businesses and institutions. Alchemy Pay Berry Cards is an innovative DeFi app on the NEAR protocol where users can jointly create pixel art NFTs. The community-driven platform mostly exists for users to enjoy participating in the Berry Club. Members come together in individual chat rooms where they can discuss their vision for their collaborative pieces. Users can add pixels to projects on the Berry Club using avocado tokens, which they can also stake on artworks to earn daily returns. Berry Club pieces are available on the Berry Card marketplace, buyers make purchases using NEAR and can resell the cards in the marketplace. Berry Cards NearZombies is an educational project that offers a unique, interactive learning process. Users get to learn about the NEAR protocol by creating an NFT avatar and working their way through chapters that feature coding tasks for users to complete as they go. It also offers a learn and earn feature where users can play a zombie game and earn Near Zombie tokens. NearZombies

The Top 15 Most Exciting Projects in the NEAR Ecosystem

Stories, News & Mentions about MYBEA

Mybea’s Stories on HackerNoon