Deworkis in the Decentralized Autonomous Organizations Industry

Dework

dework

Roxana Commands

If you have ever wondered how a Decentralised Autonomous Organisation (DAO) is run, grab a seat and read on! Do you know that a DAO, just like a traditional organization, employs a variety of tools or digital applications for different purposes? But the key difference is that a DAO’s tools are mostly decentralized applications or programs running on a blockchain. Decentralized applications, dApps for short, have a crypto wallet interface that enables DAOs to connect and navigate their websites. Dapps and other tools can altogether be found in a DAO tool kit. Here are some popular DAO tools to get familiar with! Snapshot Launched in 2020, Snapshot is a gasless web3 voting platform for DAOs. It enables DAOs to track the opinions and votes of their members openly. It is a free-to-use decentralized protocol with a simple wallet integration, and it allows DAOs to customize their experience. To vote on Snapshot, voters must be accredited (i.e., they must hold the governance token of a DAO). JuiceBox JuiceBox is the go-to platform for token launch and fundraising on the Ethereum blockchain. It is specifically built for crypto projects that want to raise funds using Ether. In 2021, Constitution DAO raised $47 million on JuiceBox from over 17,000 donors to buy a rare copy of the US constitution. It provides the infrastructure for DAOs to deploy their tokens and raise money. Safe Formerly known as Gnosis Safe, Safe is a decentralized protocol that provides on-chain custody of digital assets on the Ethereum blockchain and the EVM. Ethereum-based DAOs have millions of dollars in assets secured by Safe. Safe was initially launched in 2018 to support Ethereum, but it has now expanded to such blockchain protocols as Polygon and Binance Smart Chain. Safe has a smart contract multi-sig wallet which is suitable for DAOs as it requires a minimum number of accredited members or core contributors or a threshold to approve a transaction. DeWork DeWork is a DAO-friendly dapp that allows freelancers and members of a DAO community to apply for bounties and grants. It currently has over 500 DAOs listed on its platform, and it provides a simple wallet integration that enables successful applicants to earn rewards. DeWork makes finding job opportunities in web3 easy, and it enables DAO communities to collaborate. It is also an open-source platform where DAOs can source for quality contributors whose track records are visible. Coordinape Coordinape is specifically designed to help DAOs allocate rewards fairly to their core contributors. In other words, it is a Dapp that allows participants in a DAO to reward one another for their efforts over a given period of time. Coordinape makes the fair distribution of resources easy, transparent, and quick through ‘Gift Circles’. Discord Server The membership of a DAO can range from 50 to 20 thousand members or more. Every DAO needs a large platform such as a Discord server to bring its members together. Today, most DAO communities can be found on Discord which is a social media app for gaming, collaboration, and discussion. Discord enables DAO and other crypto-native communities to customize their experience, and it also allows them to interact with other applications outside Discord. Other DAO tools include Utopia, Deep DAO, Kali DAO, Yerba, SuperDAO, Notion, Aragon, Telegram, etc. Read more DAO articles: https://hackernoon.com/do-daos-have-the-ability-to-change-the-world

        DAO: Tool Kit for Starters

According to the Book of Genesis, Noah's descendants built a magnificent city near Babylon. They also built a tower of Babel to make a name for themselves. God was offended by the arrogance of man and decided to make a confusion of tongues so that they could not speak to one another. There is no mention in Genesis of whether God destroyed the tower, but in many deductive versions, God did so. So humans began to wander around the ruins, unable to communicate and understand each other. Source:  Daniel Larimer The story of the Tower of Babel is the best metaphor for the fragmentation of the world since the pandemic. Serious problems have cropped up between countries. We lose trust, fail to recognize the same truths, and cut ourselves off from each other and the past. For a long time, most people have been coy about cryptocurrency's encroachment on real power systems. It was not until the Russia-Ukraine War that the DAO was directly elevated to the status of national strategic organization, which also meant that the social and political experiments based on DAO were no longer castles in the air in the ideological sense, but actually entered into the practice of decentralized governance. In this paper, we will explore the possibility of productivity liberation and production relations optimization from the perspective of social consensus and proof of physical work. Look for colonial incentives Every bull market has a new growth narrative. The next cycle is bound to see many countries trying to establish new forms of violent institutions and new international economic organizations. DAOs in the decentralized sovereign category are more like national experiments. The tokenomics of cryptocurrency defines the distribution laws of the country on a macro level, while also defining the rights and obligations of its citizens on a micro level. It no longer needs to be demonstrated that bad monetary policy can wreck a country's economy. From the perspective of international law, people, territory, government, and sovereignty constitute the key elements of a sovereign state. Judging from the development of DAO today, DAO has already taken the embryonic form of a sovereign state. Mainly reflected in the following two points: This is the basis of sovereignty, coordinating the exchange of benefits according to rules written into the code of the smart contract. Ethereum is the most typical value protocol. Tokens are universally recognized and enforceable units of value, including governance tokens representing voting rights, DeFi tokens representing fiscal rights, NFTs representing the sanctity of private property rights, and security tokens representing mapping the real physical world. All of these tokens operate as code, meaning that the distribution of power should follow programmable logic. - Protocols and tokens: These are groups organized around government affairs, that is, the government in general. Allocation relationships are coordinated through sharing rules enforced on the blockchain. If DAOs and protocol tokens can establish good engagement and interconnected value networks in the ecosystem, new forms of digital organizations and states may emerge. - DAOs: Source: Andy Martin, IBM We need to understand how value is created in newly sovereign states because the sustainability of value creation and the moat of governance determine the number of citizens. Similarly, creators of sovereign DAOs must understand the investor perspective to focus most of the DAO's resources on core assets that improve the sovereign value and encourage members to contribute ideas from the bottom up. It is challenging for protocols and DAOs to keep similar companies efficient and profitable and to include token holders in sovereign governance decisions. There is a misconception that token holders should not enjoy too much of the value of the agreed income. This is classic web2 exploitative thinking. Citizens in the Web3 era enjoy absolute data ownership, which not only means that a richer application ecosystem can flourish through growing user interactions, but also that sources of power and value accumulation can be transferred completely freely. Mature DeFi protocols currently look most likely to be transformed into successful sovereign DAOs. These protocols have steadily growing cash flows and ample treasuries. They offer a variety of financial products, from lending to structured products, in addition to the fees charged by the core DEX (decentralized exchange). DeFi is therefore the most prosperous colony in the digital world. The DAO, as the coordinator of the exchange of colonial interests, creates more value through the open construction of applications within the ecosystem, captures more value through tokens, and establishes token-driven network effects. Avoid the Illusion of Power Blockchain protocols are expected to replace the constitutions and governing laws of nation-states, and since DAO participants are citizens of the network, they must be subject to cyber laws and policies. As a government, DAO also needs to establish governance rules, a legal system, an organizational structure of power balance, and high-quality public products and services. Cryptocurrencies have raced through millennia of human simulations of social governance in a few years, and experiments that bring different power systems around the world to the blockchain at Internet speed are bound to experience similar growing pains. The biggest mistake of all would be the failure of the project founders to abide by the basic principles of economics and to believe in the illusion of power derived from the short-term token boom. The determinants of the  value of DAO are: 1. Sustainability of the underlying ecosystem. 2. The long-term intrinsic utility of tokens in the ecosystem. The traditional nation-state aims to increase productivity and build a competitive advantage to achieve the long-term utility of population, trade, and monetary policies. Developed countries are rich because the government is more of an inclusive economic institution. Countries with so-called "inclusive politics" expand individual political power and property rights as widely as possible, and this is their growth engine. By contrast, if power is held by a small elite, wealth either fails to grow for long or gradually falls into a debt crisis after a brief economic expansion. We should take these lessons seriously when designing sovereign DAOs. From a development economics perspective, the network of decentralized political and economic power fits well with the design of blockchain. The value of a blockchain network is largely determined by the "resource endowment" and the national demand for goods and services, which we call block space and Gas. At this point, the similarities in power structure between DAO and the state are obvious. Start from the proof of physical work One of the most powerful features of DAOs is their ability to create colonial-like social incentive structures that allow anyone in the world to contribute to a set of governance goals without permission, and that can be frictionless and fine-tuned to facilitate large-scale inter-state coordination. These innovations link the digital and physical worlds through the token economy, known as "proof of physical work." Projects that conform to this theory motivate people to perform verifiable physical work to build the infrastructure of the physical world. One of the most notable projects is Helium and STEPN. Taking the Russia-Ukraine War as an example, the biggest feature of this war lies in the asymmetric game between the two sides' intelligence systems. The Ukrainian government directly introduced the proof of physical work mode into intelligence warfare and realized the real decentralized dimensionality reduction. Mykhailo Fedorov, who heads the digital transformation ministry of Ukraine, has proposed a project called "Smartphone Nation." Using social media as its main front, Ukraine's digital authorities have developed an intelligence App that combines technology, hacking, cryptocurrencies and the power of public opinion to provide a "find the enemy" feature -- every resident using the App can photograph and upload information about the enemy and provide a location whenever and wherever they want. Sourced ideas for crowdsourced apps can hardly be attributed to DAO. The intelligence information collected by residents is sent to soldiers on the front line through another App, which constitutes a clear "battle order". Ukrainian soldiers who receive these "battle orders" can quickly complete their missions. This governance thinking, which explicitly uses decentralized products and distributed concepts in the state apparatus, approaches the government as one of many DAOs for producing goods and services. Source: Messari Maybe you will refute me and think that UkraineDAO is the real DAO organization. But you cannot deny that DAO can be an option for a nation's digital transformation, even during wartime. Physical work proves that citizens have direct control over the machinery of violence. If the government that controls violence were in ideal shape, it would not take protection money. But in reality, the organization of commercial activities that charge "protection money" is not controlled by both producers and consumers, so it will not serve consumers by maximizing the quality of service and reducing the price charged to the greatest extent. For them, scalability is more important than maximizing profit. Think of most governments as a sort of hybrid organization; the payments that citizens make to these governments are the prices they have to pay to avoid more serious losses. If the DAO charges significantly less protection money than the government and can provide all the public services you need without even charging protection money, how will you choose? In the world of cryptocurrency, cyber citizenship is almost defined by decentralized tokens, meaning that the cost of digital migration for users is almost zero. As long as you hold the token, you are a citizen of the protocol. That's why we're seeing Web3 reputation systems like Station and social graph protocols like Lens grow in popularity because it's easier to get onto a new DAO than it is to get into the U.S. One person may be an active citizen of dozens of DAOs, which will greatly contribute to thriving international trade among DAOs and even solve the impossible triangle in international trade, which you can read more about . here Where should we go? First, a successful sovereign DAO should have the following three components: 1. Network incentive model (liquidity source); 2.Community engagement (value interaction); 3. Adequate decentralization (governance capacity); As proof of physical work mechanisms is refined, many components of DAO activities, including frictional costs and computational rules in production and trading activities, will be replaced by hardware machines and smart contracts. This is why DeFi is the first application direction for sovereign DAOs to break out. In summary, the primary goal of DAOs is to attract and retain high-quality digital citizens, thereby attracting sustainable demand and adding value to the network. Of course, the success of a country is more complex than the token economy and DAO governance design. But there is no doubt that DAOs provide builders with a much richer toolbox than traditional states. Anything in a legal document or monetary policy can run on the blockchain. StepN is a move-to-earn application built on Solana. Its success lies in building rich economic models, vibrant in-app activities, and vibrant cross-chain interactions. I think they could try new governance models that not only reward token holders for ownership but also think about rewarding people for participation and contribution. If there is a major innovation in their governance paradigm, I believe this model based on economic governance can be extended to outer space colonies. Nation3 had a more specific goal, creating a community designed to provide services similar to nation-state services, such as money, education, health care, and so on. The project hopes to build a fair nation of encryption on the cloud. Their unique "union + proposal + Dework + community members" model is working, and it is still cash flow issues that affect the development of the project. Because building a Web3 country often seems like a grand narrative rather than a clear source of cash flow for Web3 apps. Therefore, such projects should still prioritize the operation of Treasury assets and the value interaction with DeFi assets. The construction of a national DAO should start from the following points; - Territory is not necessary for a cloud state, but it must have the ability to protect its citizens, which means it can skip the territory and run the machine of violence, but there is no new exploration mode for this track; - Government is the institution that keeps society functioning. DAO amounts to suggesting an efficient and equitable governance mechanism and a functioning social system, which is very difficult to balance; - Physical proof of work mechanisms that meet the interface needs of digital citizens and the real world. These interfaces need to include a currency exchange interface, physical authentication interface, and physical transaction interface. This is an era of confusion and injustice, but it is also an era of reflection and reset. On a longer timescale, the order of magnitude and opportunities for Web3 countries will be much greater than they are today. DAOs can structure any current economy and governance pattern through programmable currencies, code-based laws, and composability. Of course, there are plenty of problems, including decentralized decisions that tend to be inefficient, code errors that lead to money being stolen, and so on. But when we stop focusing on dysfunctional, centralized government and talk directly to DAO members, we are already transforming ourselves and society.

Rebuilding the Tower of Babel: A Theory of New National Development Based on DAO

Reconstruyendo la Torre de Babel: una teoría del nuevo desarrollo nacional basada en DAO

There are plenty of opportunities to earn and grow as a contributor to blockchain tech even without being a developer fluent in Solidity, Rust or some other complex foreign computer language. To find these opportunities, you really have to know where to look, and it helps to think “outside the box”. Work of all types is being sought after by blockchain-based companies. The work can range from simple jobs like making memes to more skilled tasks like POAP (Proof of Attendance Protocol) Design or in-depth research articles. There are several websites where you can search and find hundreds of jobs or tasks, and a person seeking earning opportunities in any of the places I’ll mention is sure to find some. DAO Bounties The relatively new concept and creation of DAOs (Decentralized Autonomous Organizations) have created a flood of new jobs needing contributors to join in and contribute to community growth, marketing needs, content creation, design tasks and social media growth, management, etc. One such site is Dework, which currently offers a list of over 300 open bounties for a wide range of varying skill sets. The companies and DAOs that are using these sites could either be startups or established companies that have been around for a couple of years. New bounties are being listed daily and are practically permissionless. Once completed, bounties need only approval before they can be added to your portfolio, demonstrating proof of work and reputation as a blockchain contributor. Dework’s user interface and overall website structure are both pretty easy to understand and navigate. You’ll find plenty of open bounties and many accepting multiple submissions. Other bounties require applications or are by request only, so they’ll need to be assigned by a DAO member or company representative. All communication regarding these bounties can be made through the Discord community for the project. There is no shortage of jobs needing completion or ways to earn crypto for your contributions. Crypto-Based Contests Another great place to find some nifty options from some of the most up-and-coming projects is to look on Layer3 at the contests page. There are always some crypto-incentivized jobs that are available to find here. The bounties are more of a source to learn from and gain hands-on knowledge using several blockchain products available. I have noticed an occasional monetary bounty pop up here and there, but most ways to get crypto on Layer3 are on the contest page. Competition is growing, meaning high-quality work is necessary to win. It’s an effective way to see how your work stands up compared to your peers. The third source for potential work I want to mention is Kleoverse. The ecosystem is new, and the setup is not yet optimal, but there is value to be found here. Various DAOs are using this platform, making it grow to create more profit potential. Those are my top 3 choices for websites I regularly used to earn or learn. They are all pretty straightforward to use, so they are the best sources for finding bounties, small tasks, and even longer or ongoing projects needing contributors to complete them. Outside The Box Earlier, I mentioned thinking “outside the box” helps find more chances to earn, and I’ll mention two ideas that will hopefully inspire or even point you towards becoming an active and valued contributor to blockchain growth. The first place to check out is the forum Bitcoin Talk under the thread called Bounty Good. In this forum, you’ll find a fairly reliable list of new projects needing simple tasks that can be performed by anybody and pay in their native cryptocurrency. Not all the projects found here are going to the moon. However, the curator of this list finds valid projects needing quick tasks for the startup’s launch, making it a useful and “outside the box” source of possibilities. My last and final suggestion is to look within publications just like this one, Hackernoon. Often you’ll see contests being sponsored by blockchain companies like or BrickTrade that generally are offering cash prizes. So leave no stone unturned and no path not ventured on your journey to becoming involved with the emerging blockchain technology. Tatum This article was first published here.

Where You Can Go To Create Value And Earn Money With The Blockchain

After 7 years working as Senior Data Manager at Criteo and as Head of Data at Payfit, and after interviewing 200+ data leaders for user research, I am starting to have a good overview of data stacks in action. So, by popular demand, I’m dropping here and there some advice on the trends I observed. Earlier in March, I had two different calls: one from a former colleague, now head of data at , and one from a friend, now head of data at . Both had taken a new job and had to build a complete data stack, from scratch! I assume this could interest others. Here is the piece of advice I gave them. Swile Cajoo Before we start, here is a Decision Matrix that you can use for benchmark purposes: Ease of Use Integration in Cloud environment Community & Documentation Governance Capabilities Pricing To keep things simple, we’ll just follow the data, from source to reporting. Data Warehouse Where you store your data for analytics needs A data warehouse is a place you store and organize your data before analysts use it My recommendation is simple: If your dev stack runs on Google Cloud, then go for BigQuery (BQ) If your dev stack runs on AWS, then go for Snowflake (SF) Here are a few reasons. Redshift was indeed the first big player on the Cloud Data Warehouse market, but it means they’ve made mistakes that followers could avoid, and they haven’t changed much for the last few years. Redshift has a poor UI/UX, especially for end-users (data consumers). BigQuery and Snowflake are quite similar in terms of features and pricing models (based on usage: BQ bills you by scanned data, Snowflake bills you by query time). A slight difference is that the first one is stronger when the whole stack is run on Google Cloud while the second is slightly more “Analytics” focused, making it a perfect match for AWS users. Snowflake is heading towards being a full data platform (multi-cloud, Snowpipe, jobs, data share, python/js functions) with a friendly user interface. BigQuery’s strength is its integration within the Google Cloud systems: read/write from GCS, IAM rights management, billing, Google Spreadsheets native integration, …) Ingestion Get Data in your Data Warehouse Stitch and Fivetran are extracting data from all your business sources and bring them to your Data Warehouse For data originating from a SaaS, use or . These two companies do a great job at maintaining these data dumps for their thousands of clients, and their pricing is linear as well as predictable. The sources they can retrieve data from is numerous, check these and . StitchData Fivetran here here You may want to cherry-pick some tables to ingest yourself, for frequency reasons or whatever. Make sure to leverage the numerous open-source taps made available . here Want a mix between the fully managed and the fully homemade? Check . You’ll have to host it but it comes with the necessary bunch of features, sources, and destinations. Airbyte provides similar features, depending on the plan you’re on. But focuses more on event tracking, it’s a must-have to sync your marketing campaigns with user activity. Think of Segment as the big ears listening to what is happening on your website/app. It also demands an ongoing tagging plan. An alternative is which does not integrate that well with other data sources but does not require a tagging plan Segment Contentsquare Do not worry, there is still plenty of DE work to do: you’ve got ingestion pipelines to build for all your data. If your PROD is in NoSQL (such as Mongo), then you’ve got the transformation to do before ingesting the data in your data warehouse. If your PROD is already in a SQL format, then you can dump all needed data in your analytics warehouse, and directly move on to the next paragraph production Transformation From raw data to model/reports ready Like any raw material, you want to transform it to deliver value. Use DBT to transform data. First things first, (note the L now in the middle). In recent years, storage costs decreased to a point (< $30 per Tb/month) where you can now load all raw data in your data warehouse, and then do the transformation in SQL. Keep in mind that storage in SF and BQ is as cheap as S3 storage is, it’s computing that costs money. ETL is dead, long live ELT Now, putting the spotlight on what became the obvious tool in 90% of the data teams I’ve talked to: the notorious . There is even a new job title that comes with it: . DBT is open source, quite easy to set up, and comes with a bunch of interesting features oriented on quality, such as unit tests. DBT Analytics Engineer The general idea is to load all your data in your warehouse, then use DBT to create your datamart ie: refined data, ready to be used for analytics purposes. As a side note, DBT is not a scheduler, you’ll still have to schedule it. It’s your scheduler who’ll launch the DBT executions… which naturally leads me to the scheduler section below. One last note: end of last year Google , it’s now free and well-integrated with Big Query, but the community is not that big. acquired Dataform Scheduler Run job 1 then run job 2 In any transformation process, there is a schedule. Things have to happen in a certain order. Use Airflow for data transformation scheduling. The market standard for scheduling really boils down to Airflow, the question is which deployment setup you want? You can go for: Self-Managed: dockerized airflow Managed: AWS version / GCP Version Fully-Managed: Astronomer Astronomer helps you get off the ground faster. But there is a cost for that… Data Viz Make your shiny dashboards Once you have a high-value dataset, you will want to show the output in the sexiest and most understandable way. Data visualization with , , or is the best option. Tableau Looker Metabase This one is tough, as competition is fierce within this segment. This will also be the only part your business users will see, out of the whole stack you are building. Strong options are , , or . I know that there are a lot of other options out there, that’s just my opinion Tableau Looker Metabase I’ll make a dedicated article on the matter, but to start, go for Metabase. First, on the data Viz side, it’s simple and straightforward, it takes a few minutes to go from a table to a dashboard. Keep in mind that for a while your dashboards will be simple, as you need to educate the different teams. Oh, and it’s free as long as you host it yourself. Data Discovery Find, understand and use data faster High-value datasets or analyses are useless if no one knows they exist. Make sure people do. Castor is the tool for that. Do you think that data discovery is only for people with too much data or many people? Did you know that after a few data dumps from Stitch or Segment, you’ll already have hundreds of tables? On top of that, I’m quite sure that the first data analyst or engineer you’ll hire will make their own data documentation on a google doc or else. Wouldn’t it be better to have that info accessible to everyone and especially to the second hire? At Castor, we provide just that! is a data documentation tool for the Notion-Figma-Slack generation. Or data-wise, for the Fivetran-Looker-Snowflake-DBT aficionados. We designed our catalog to be . Castor easy to use, automated, delightful, and friendly Want to check it out? and we will show you a demo. Reach out to us

How to Build a Data Stack from Scratch

A Guide to Troubleshooting Frequent Compile-Time Errors: C# for Beginners

Async/await in C# is a framework used for writing asynchronous C# code that is both readable and maintainable. These tips will help you to integrate async/await programming more effectively in the # projects: 1. ValueTask for Lightweight Operations Use ValueTask instead of Task for asynchronous methods that often complete synchronously, reducing the allocation overhead. public async ValueTask<int> GetResultAsync()
    {
        if (cachedResult != null)
            return cachedResult;
        int result = await ComputeResultAsync();
        cachedResult = result;
        return result;
    } 2. ConfigureAwait for Library Code Use ConfigureAwait(false) in the library code to avoid deadlocks by not capturing the synchronization context. public async Task SomeLibraryMethodAsync()
    {
        await SomeAsyncOperation().ConfigureAwait(false);
    } 3. Avoiding async void Prefer async Task over async void except for event handlers, as async void can lead to unhandled exceptions and is harder to test. public async Task EventHandlerAsync(object sender, EventArgs e)
    {
        await PerformOperationAsync();
    } 4. Using IAsyncDisposable For asynchronous cleanup, implement IAsyncDisposable and use await to ensure resources are released properly. public async ValueTask DisposeAsync()
    {
        await DisposeAsyncCore();
    }
    
    private async ValueTask DisposeAsyncCore()
    {
        if (resource != null)
        {
            await resource.DisposeAsync();
        }
    } 5. Efficiently Combine Tasks Use Task.WhenAll for running multiple tasks in parallel and waiting for all to complete, which is more efficient than awaiting each task sequentially public async Task ProcessTasksAsync()
    {
        Task task1 = DoTask1Async();
        Task task2 = DoTask2Async();
        await Task.WhenAll(task1, task2);
    } 6. Cancellation Support Support cancellation in asynchronous methods using CancellationToken. public async Task DoOperationAsync(CancellationToken cancellationToken)
    {
        await LongRunningOperationAsync(cancellationToken);
        cancellationToken.ThrowIfCancellationRequested();
    } 7. State Machine Optimization For performance-critical code, consider structuring your async methods to minimize the creation of state machines by separating synchronous and asynchronous paths. public async Task<int> FastPathAsync()
    {
        if (TryGetCachedResult(out int result))
        {
            return result;
        }
        return await ComputeResultAsync();
    } 8. Avoid Blocking Calls Avoid blocking on async code with .Result or .Wait(). Instead, use asynchronous waiting through the stack. public async Task WrapperMethodAsync()
    {
        int result = await GetResultAsync();
    } 9. Eliding Async/Await In simple passthrough scenarios or when returning a task directly, you can elide the async and await keywords for slightly improved performance. public Task<int> GetResultAsync() => ComputeResultAsync(); 10. Custom Task Schedulers For advanced scenarios, like limiting concurrency or capturing synchronization contexts, consider implementing a custom TaskScheduler. public sealed class LimitedConcurrencyLevelTaskScheduler : TaskScheduler
    {
        // Implement the scheduler logic here.
    } 11. Using Asynchronous Streams Leverage asynchronous streams with IAsyncEnumerable<T> for processing sequences of data asynchronously, introduced in C# 8.0. public async IAsyncEnumerable<int> GetNumbersAsync()
    {
        for (int i = 0; i < 10; i++)
        {
            await Task.Delay(100); // Simulate async work
            yield return i;
        }
    } 12. Avoid Async Lambdas in Hot Paths Async lambdas can introduce overhead. In performance-critical paths, consider refactoring them into separate async methods. // Before optimization
    Func<Task> asyncLambda = async () => await DoWorkAsync();
    
    // After optimization
    public async Task DoWorkMethodAsync()
    {
        await DoWorkAsync();
    } 13. Use SemaphoreSlim for Async Coordination SemaphoreSlim can be used for async coordination, such as limiting access to a resource in a thread-safe manner. private readonly SemaphoreSlim semaphore = new SemaphoreSlim(1, 1);
    
    public async Task UseResourceAsync()
    {
        await semaphore.WaitAsync();
        try
        {
            // Access the resource
        }
        finally
        {
            semaphore.Release();
        }
    } 14. Task.Yield for UI Responsiveness Use await Task.Yield() in UI applications to ensure the UI remains responsive by allowing other operations to process. public async Task LoadDataAsync()
    {
        await Task.Yield(); // Return control to the UI thread
        // Load data here
    } 15. Asynchronous Lazy Initialization Use Lazy<Task<T>> for asynchronous lazy initialization, ensuring the initialization logic runs only once and is thread-safe. private readonly Lazy<Task<MyObject>> lazyObject = new Lazy<Task<MyObject>>(async () =>
    {
        return await InitializeAsync();
    });
    
    public async Task<MyObject> GetObjectAsync() => await lazyObject.Value; 16. Combining async and LINQ Be cautious when combining async methods with LINQ queries; consider using asynchronous streams or explicitly unwrapping tasks when necessary. public async Task<IEnumerable<int>> ProcessDataAsync()
    {
        var data = await GetDataAsync(); // Assume this returns Task<List<int>>
        return data.Where(x => x > 10);
    } 17. Error Handling in Async Streams Handle errors gracefully in asynchronous streams by encapsulating the yielding loop in a try-catch block. public async IAsyncEnumerable<int> GetNumbersWithErrorsAsync()
    {
        try
        {
            for (int i = 0; i < 10; i++)
            {
                if (i == 5) throw new InvalidOperationException("Test error");
                yield return i;
            }
        }
        catch (Exception ex)
        {
            // Handle or log the error
        }
    } 18. Use Parallel.ForEachAsync for Asynchronous Parallel Loops Utilize Parallel.ForEachAsync in .NET 6 and later for running asynchronous operations in parallel, providing a more efficient way to handle CPU-bound and I/O-bound operations concurrently. await Parallel.ForEachAsync(data, async (item, cancellationToken) =>
    {
        await ProcessItemAsync(item, cancellationToken);
    }); 22. Avoid Excessive Async/Await in High-Performance Code In performance-critical sections, minimize the use of async/await. Instead, consider using Task.ContinueWith with caution or redesigning the workflow to reduce asynchronous calls. Task<int> task = ComputeAsync();
    task.ContinueWith(t => Process(t.Result)); 23. Async Main Method Utilize the async entry point for console applications introduced in C# 7.1 to simplify initialization code. public static async Task Main(string[] args)
    {
        await StartApplicationAsync();
    } 24. Optimize Async Loops For loops performing asynchronous operations, consider batching or parallelizing tasks to improve throughput. var tasks = new List<Task>();
    for (int i = 0; i < items.Length; i++)
    {
        tasks.Add(ProcessItemAsync(items[i]));
    }
    await Task.WhenAll(tasks); More Cheatsheets Cheat Sheets - .Net C# Programming🚀 Thank you for being a part of the C# community! Before you leave: Follow us: | | | Visit our other platforms: More content at Youtube X LinkedIn Dev.to GitHub C# Programming Also published . here

Async/Await For Basic to Advanced C# Developers: 24 Essential Tips

Dependency Injection in is a lifesaver when organizing dependencies — especially in more complex ASP.NET Core applications. And if you’re already or just want to stick as close as possible to the already provided DI offerings, is a great enhancement. C# familiar with IServiceCollection Scrutor in C# In this article, I’ll provide you with a high-level overview of Dependency Injection and Scrutor in C#. But from there, we’re jumping right into 3 tips that you can use with Scrutor that could prove to be very helpful in your application! What is Scrutor in C#? Scrutor is a powerful NuGet package in C# that enhances dependency injection. It simplifies the registration and resolution of dependencies, making it easier for you to manage and organize your code. Dependency injection is a popular approach to configuring applications that promotes loose coupling and improves testability and maintainability. It involves injecting dependencies into a class rather than directly creating them within the class. This means that the responsibility of creating the dependency is not owned by the class requiring it, but instead, owned by someone up the call stack. Eventually, this pushes nearly all dependency creation to the entry point of an application, making it unwieldy. However,  dependency injection frameworks help . clean up and organize all of this logic Scrutor takes this concept a step further by providing a simple and intuitive way to register and resolve dependencies. With Scrutor, you no longer need to manually register each dependency one by one. Instead, you can use conventions and attributes to automate the process. 1 – Using Scrutor for Registration and Resolution To illustrate how to use Scrutor in C# for registration and resolution, let’s consider a simple scenario. Imagine we have an application that requires the use of different data repositories, such as UserRepository and ProductRepostiory. First, we need to install the Scrutor NuGet package in our project. Open the Package Manager Console and run the following command: Install-Package Scrutor Next, we need to define our repositories and their corresponding interfaces. This example is essentially empty, but we’ll be referring to these in a moment: public interface IUserRepository
{
    // Interface methods
}
public class UserRepository : IUserRepository 
{
    // Implementation
}

public interface IProductRepository
{
    // Interface methods
}

public class ProductRepository : IProductRepository
{
    // Implementation
} Now, let’s wire up our dependencies using Scrutor. In your startup code (such as in the ConfigureServices method in ASP.NET Core), add the following code: services.Scan(scan => scan
    .FromAssemblyOf<Startup>()
    .AddClasses(classes => classes.AssignableToAny(
        typeof(IUserRepository),
        typeof(IProductRepository)))
    .AsImplementedInterfaces()
    .WithScopedLifetime()); This code uses the Scan method from Scrutor to scan the assembly that contains the Startup class. It then filters out the classes that are assignable to IUserRepository or IProductRepository interfaces. Finally, it maps the implementations of these interfaces and registers them with their respective interfaces. Now, we can inject these dependencies into our classes. For example, let’s say we have a UserService class that requires IUserRepository: public class UserService 
{
    private readonly IUserRepository _userRepository; 
    
    public UserService(IUserRepository userRepository) 
    { 
        _userRepository = userRepository;
    }

    // Rest of the class implementation
} By declaring IUserRepository as a dependency in the constructor, Scrutor along with IServiceCollection will automatically resolve and inject the UserRepository instance for us. 2 – The Decorator Pattern – Example of Logging for Services Imagine you have a service interface and an implementation . You want to log the entry and exit of each method call in without polluting its business logic with logging concerns. IService MyService MyService First, define the interface and its implementation: IService public interface IService
{
    void DoWork();
}

public class MyService : IService
{
    public void DoWork()
    {
        // Business logic here
    }
} Next, create a decorator class that implements . This class will wrap the actual service and add logging around the delegated method calls: LoggingDecorator IService public class LoggingDecorator : IService
{
    private readonly IService _decorated;
    private readonly ILogger<LoggingDecorator> _logger;

    public LoggingDecorator(IService decorated, ILogger<LoggingDecorator> logger)
    {
        _decorated = decorated;
        _logger = logger;
    }

    public void DoWork()
    {
        _logger.LogInformation("Starting work.");
        _decorated.DoWork();
        _logger.LogInformation("Finished work.");
    }
} Now, use Scrutor to register your service and its decorator in the or wherever you configure your services: Startup.cs public void ConfigureServices(IServiceCollection services)
{
    // Register the base service
    services.AddScoped<IService, MyService>();

    // Use Scrutor to apply the decorator
    services.Decorate<IService, LoggingDecorator>();

    // Make sure to register the ILogger or ILogger<T> dependencies if not already done

} This setup uses Scrutor to wrap the registration with the . When resolving , the DI container will provide an instance of , which in turn wraps an instance of . This approach achieves the separation of concerns by keeping the logging logic outside of your business logic. IService LoggingDecorator IService LoggingDecorator MyService 3 – Feature Toggle for Service Implementations When we’re building complex systems, there are often cases where we want to introduce something like feature flags. These allow us to take different code paths based on configuration and not have to recompile and deploy an entire application. In some situations, it’s not just about picking a different code path, it’s about swapping an entire implementation of something! Let’s try out an example together! Assume you have an interface with multiple implementations: (a new, experimental feature) and (the current, stable feature). You want to switch between these implementations at runtime based on a configuration flag. IFeatureService NewFeatureService StandardFeatureService First, define the interface and its implementations: IFeatureService public interface IFeatureService
{
    void ExecuteFeature();
}

public class NewFeatureService : IFeatureService
{
    public void ExecuteFeature()
    {
        // New feature logic
    }
}

public class StandardFeatureService : IFeatureService
{
    public void ExecuteFeature()
    {
        // Standard feature logic
    }
} Next, you need a way to determine which implementation to use based on a feature toggle setting. This could be a value in , a database setting, or any other configuration source. appsettings.json Now, use Scrutor to dynamically register the appropriate service implementation based on the feature toggle: public void ConfigureServices(IServiceCollection services)
{
    // Assume GetFeatureToggleValue() retrieves the current feature toggle setting
    var useNewFeature = GetFeatureToggleValue("UseNewFeature");

    // Dynamically register the appropriate implementation based on the feature toggle
    if (useNewFeature)
    {
        services.AddScoped<IFeatureService, NewFeatureService>();
    }
    else
    {
        services.AddScoped<IFeatureService, StandardFeatureService>();
    }

    // Optional: You could combine this with the previous example
    // to use the decorator pattern too!
    // services.Decorate<IFeatureService, FeatureServiceProxy>();
}

private bool GetFeatureToggleValue(string featureName)
{
    // This method would typically check your
    // configuration source to determine if the feature is enabled
    // For simplicity, this is just a placeholder
    return false; // or true based on actual configuration
} Taking an approach like this can help us with: : Allows the application to switch between feature implementations without needing to redeploy. You can enable or disable features with just a configuration change. Flexibility : You can test new features in a production environment with a limited set of users by toggling the feature on for those users. Testing in Production : Helps in rolling out features gradually to monitor the impact and ensure stability before a wider release. Gradual Rollouts : Quickly revert to the old implementation if issues arise with the new feature, minimizing downtime and impact on users. Risk Mitigation Wrapping Up Scrutor in C# In this article, I provided you with 3 simple tips for dependency injection with Scrutor in C#. After a brief overview of what dependency injection is and how Scrutor fits into it, we jumped right into our examples. We got to see assembly scanning, how to decorate dependencies, and even how to consider feature flagging entire implementations! Dependency injection is something that can greatly simplify your applications as they grow in complexity, and Scrutor can be a huge help if you want to stick to the . If you found this useful and you’re looking for more learning opportunities, consider and check out my ! Join me and the ! built-in IServiceCollection offering from Microsoft subscribing to my free weekly software engineering newsletter free videos on YouTube other community members on Discord Also published here.

3 Simple Tips For Dependency Injection Using Scrutor in C#

C# এ স্ক্রুটার ব্যবহার করে নির্ভরতা ইনজেকশনের জন্য 3 টি সহজ টিপস

3 einfache Tipps für die Abhängigkeitsinjektion mit Scrutor in C#

Tres consejos sencillos para la inyección de dependencias utilizando Scrutor en C#

3 conseils simples pour l'injection de dépendances à l'aide de Scrutor en C#

C# में स्क्रूटर का उपयोग करके निर्भरता इंजेक्शन के लिए 3 सरल युक्तियाँ

C# で Scrutor を使用した依存関係の注入に関する 3 つの簡単なヒント

C#에서 Scrutor를 사용하여 종속성 주입을 위한 3가지 간단한 팁

3 dicas simples para injeção de dependência usando Scrutor em C#

3 простых совета по внедрению зависимостей с помощью Scrutor в C#

C#'ta Scrutor Kullanarak Bağımlılık Enjeksiyonu İçin 3 Basit İpucu

3 mẹo đơn giản để chèn phụ thuộc bằng Scrutor trong C#

在 C# 中使用 Scrutor 进行依赖注入的 3 个简单技巧

This paper is available on arxiv under CC 4.0 license. Authors: (1) Ruta Jawale; (2) Dakshita Khurana. Table of Links Abstract and Introduction Technical Overview Preliminaries Unclonable Non-Interactive Zero-Knowledge in the CRS Model Unclonable NIZK in the Quantum Ramdon Oracle Model Unclonable Signatures of Knowledge References References [Aar09] Scott Aaronson. Quantum copy-protection and quantum money. In Proceedings of the 24th Annual IEEE Conference on Computational Complexity, CCC 2009, Paris, France, 15-18 July 2009, pages 229–242. IEEE Computer Society, 2009. [AC13] Scott Aaronson and Paul F. Christiano. Quantum money from hidden subspaces. Theory Comput., 9:349–401, 2013. [AGKZ20] Ryan Amos, Marios Georgiou, Aggelos Kiayias, and Mark Zhandry. One-shot signatures and applications to hybrid quantum/classical authentication. In Konstantin Makarychev, Yury Makarychev, Madhur Tulsiani, Gautam Kamath, and Julia Chuzhoy, editors, Proccedings of the 52nd Annual ACM SIGACT Symposium on Theory of Computing, STOC 2020, Chicago, IL, USA, June 22-26, 2020, pages 255–268. ACM, 2020. [AK21] Prabhanjan Ananth and Fatih Kaleoglu. Unclonable encryption, revisited. In Kobbi Nissim and Brent Waters, editors, Theory of Cryptography - 19th International Conference, TCC 2021, Raleigh, NC, USA, November 8-11, 2021, Proceedings, Part I, volume 13042 of Lecture Notes in Computer Science, pages 299–329. Springer, 2021. [AKL+22] Prabhanjan Ananth, Fatih Kaleoglu, Xingjian Li, Qipeng Liu, and Mark Zhandry. On the feasibility of unclonable encryption, and more. In Yevgeniy Dodis and Thomas Shrimpton, editors, Advances in Cryptology - CRYPTO 2022 - 42nd Annual International Cryptology Conference, CRYPTO 2022, Santa Barbara, CA, USA, August 15-18, 2022, Proceedings, Part II, volume 13508 of Lecture Notes in Computer Science, pages 212–241. Springer, 2022. [ALL+21] Scott Aaronson, Jiahui Liu, Qipeng Liu, Mark Zhandry, and Ruizhe Zhang. New approaches for quantum copy-protection. In Tal Malkin and Chris Peikert, editors, Advances in Cryptology - CRYPTO 2021 - 41st Annual International Cryptology Conference, CRYPTO 2021, Virtual Event, August 16-20, 2021, Proceedings, Part I, volume 12825 of Lecture Notes in Computer Science, pages 526–555. Springer, 2021. [AN11] Tolga Acar and Lan Nguyen. Revocation for delegatable anonymous credentials. In Dario Catalano, Nelly Fazio, Rosario Gennaro, and Antonio Nicolosi, editors, Public Key Cryptography - PKC 2011 - 14th International Conference on Practice and Theory in Public Key Cryptography, Taormina, Italy, March 6-9, 2011. Proceedings, volume 6571 of Lecture Notes in Computer Science, pages 423–440. Springer, 2011. [AP21] Prabhanjan Ananth and Rolando L. La Placa. Secure software leasing. In Anne Canteaut and Franc¸ois-Xavier Standaert, editors, Advances in Cryptology - EUROCRYPT 2021 - 40th Annual International Conference on the Theory and Applications of Cryptographic Techniques, Zagreb, Croatia, October 17-21, 2021, Proceedings, Part II, volume 12697 of Lecture Notes in Computer Science, pages 501–530. Springer, 2021. [BCC+09] Mira Belenkiy, Jan Camenisch, Melissa Chase, Markulf Kohlweiss, Anna Lysyanskaya, and Hovav Shacham. Randomizable proofs and delegatable anonymous credentials. In Shai Halevi, editor, Advances in Cryptology - CRYPTO 2009, 29th Annual International Cryptology Conference, Santa Barbara, CA, USA, August 16-20, 2009. Proceedings, volume 5677 of Lecture Notes in Computer Science, pages 108–125. Springer, 2009. [BGG+23] James Bartusek, Sanjam Garg, Vipul Goyal, Dakshita Khurana, Giulio Malavolta, Justin Raizes, and Bhaskar Roberts. Obfuscation and outsourced computation with certified deletion. Cryptology ePrint Archive, Paper 2023/265, 2023. [BI20] Anne Broadbent and Rabib Islam. Quantum encryption with certified deletion. In Rafael Pass and Krzysztof Pietrzak, editors, Theory of Cryptography, pages 92–122, Cham, 2020. Springer International Publishing. [BK23] James Bartusek and Dakshita Khurana. Cryptography with certified deletion. In Crypto 2023 (to appear), 2023. [BKP23] James Bartusek, Dakshita Khurana, and Alexander Poremba. Publicly-verifiable deletion via target-collapsing functions. In Crypto 2023 (to appear), 2023. [BL20] Anne Broadbent and S´ebastien Lord. Uncloneable quantum encryption via oracles. In Steven T. Flammia, editor, 15th Conference on the Theory of Quantum Computation, Communication and Cryptography, TQC 2020, June 9-12, 2020, Riga, Latvia, volume 158 of LIPIcs, pages 4:1–4:22. Schloss Dagstuhl - Leibniz-Zentrum f ¨ur Informatik, 2020. [BS16] Shalev Ben-David and Or Sattath. Quantum tokens for digital signatures. CoRR, abs/1609.09047, 2016. [BS17] Shalev Ben-David and Or Sattath. Quantum tokens for digital signatures. IACR Cryptol. ePrint Arch., page 94, 2017. [BS23a] Mohammed Barhoush and Louis Salvail. How to sign quantum messages, 2023. [BS23b] Mohammed Barhoush and Louis Salvail. Powerful primitives in the bounded quantum storage model, 2023. [CKS10] Jan Camenisch, Markulf Kohlweiss, and Claudio Soriente. Solving revocation with efficient update of anonymous credentials. In Juan A. Garay and Roberto De Prisco, editors, Security and Cryptography for Networks, 7th International Conference, SCN 2010, Amalfi, Italy, September 13-15, 2010. Proceedings, volume 6280 of Lecture Notes in Computer Science, pages 454–471. Springer, 2010. [CL06] Melissa Chase and Anna Lysyanskaya. On signatures of knowledge. In Cynthia Dwork, editor, Advances in Cryptology - CRYPTO 2006, 26th Annual International Cryptology Conference, Santa Barbara, California, USA, August 20-24, 2006, Proceedings, volume 4117 of Lecture Notes in Computer Science, pages 78–96. Springer, 2006. [CLLZ21] Andrea Coladangelo, Jiahui Liu, Qipeng Liu, and Mark Zhandry. Hidden cosets and applications to unclonable cryptography. In Tal Malkin and Chris Peikert, editors, Advances in Cryptology - CRYPTO 2021 - 41st Annual International Cryptology Conference, CRYPTO 2021, Virtual Event, August 16-20, 2021, Proceedings, Part I, volume 12825 of Lecture Notes in Computer Science, pages 556–584. Springer, 2021. [CW19] Xavier Coiteux-Roy and Stefan Wolf. Proving erasure. In IEEE International Symposium on Information Theory, ISIT 2019, Paris, France, July 7-12, 2019, pages 832–836, 2019. [FGH+12] Edward Farhi, David Gosset, Avinatan Hassidim, Andrew Lutomirski, and Peter W. Shor. Quantum money from knots. In Shafi Goldwasser, editor, Innovations in Theoretical Computer Science 2012, Cambridge, MA, USA, January 8-10, 2012, pages 276–289. ACM, 2012. [FLS90] Uriel Feige, Dror Lapidot, and Adi Shamir. Multiple non-interactive zero knowledge proofs based on a single random string (extended abstract). In 31st Annual Symposium on Foundations of Computer Science, St. Louis, Missouri, USA, October 22-24, 1990, Volume I, pages 308–317. IEEE Computer Society, 1990. [FM18] Honghao Fu and Carl A. Miller. Local randomness: Examples and application. Phys. Rev. A, 97:032324, Mar 2018. [GMR89] Shafi Goldwasser, Silvio Micali, and Charles Rackoff. The knowledge complexity of interactive proof systems. SIAM J. Comput., 18(1):186–208, 1989. [Got03] Daniel Gottesman. Uncloneable encryption. Quantum Inf. Comput., 3(6):581–602, 2003. [GZ20] Marios Georgiou and Mark Zhandry. Unclonable decryption keys. IACR Cryptol. ePrint Arch., page 877, 2020. [HMNY21] Taiga Hiroka, Tomoyuki Morimae, Ryo Nishimaki, and Takashi Yamakawa. Quantum encryption with certified deletion, revisited: Public key, attribute-based, and classical communication. In Mehdi Tibouchi and Huaxiong Wang, editors, Advances in Cryptology – ASIACRYPT 2021, pages 606–636, Cham, 2021. Springer International Publishing. [HMNY22] Taiga Hiroka, Tomoyuki Morimae, Ryo Nishimaki, and Takashi Yamakawa. Certified everlasting zero-knowledge proof for QMA. CRYPTO, 2022. https://ia.cr/2021/1315. [IBM23] IBM. Cost of a data breach report 2023. Technical report, IBM, 2023. [Kan18] Daniel M. Kane. Quantum money from modular forms. CoRR, abs/1809.05925, 2018. [KN23] Fuyuki Kitagawa and Ryo Nishimaki. One-out-of-many unclonable cryptography: Definitions, constructions, and more. IACR Cryptol. ePrint Arch., page 229, 2023. [KT20] Srijita Kundu and Ernest Y. Z. Tan. Composably secure device-independent encryption with certified deletion, 2020. [LS19] Alex Lombardi and Luke Schaeffer. A note on key agreement and noninteractive commitments. Cryptology ePrint Archive, Paper 2019/279, 2019. https://eprint.iacr.org/2019/279. [LZ19] Qipeng Liu and Mark Zhandry. Revisiting post-quantum fiat-shamir. In Alexandra Boldyreva and Daniele Micciancio, editors, Advances in Cryptology - CRYPTO 2019 - 39th Annual International Cryptology Conference, Santa Barbara, CA, USA, August 18-22, 2019, Proceedings, Part II, volume 11693 of Lecture Notes in Computer Science, pages 326–355. Springer, 2019. [MST21] Christian Majenz, Christian Schaffner, and Mehrdad Tahmasbi. Limitations on uncloneable encryption and simultaneous one-way-to-hiding. IACR Cryptol. ePrint Arch., page 408, 2021. [Por22] Alexander Poremba. Quantum proofs of deletion for learning with errors. Cryptology ePrint Archive, Report 2022/295, 2022. https://ia.cr/2022/295. [PS19] Chris Peikert and Sina Shiehian. Noninteractive zero knowledge for NP from (plain) learning with errors. In Alexandra Boldyreva and Daniele Micciancio, editors, Advances in Cryptology - CRYPTO 2019 - 39th Annual International Cryptology Conference, Santa Barbara, CA, USA, August 18-22, 2019, Proceedings, Part I, volume 11692 of Lecture Notes in Computer Science, pages 89–114. Springer, 2019. [Sah99] Amit Sahai. Non-malleable non-interactive zero knowledge and adaptive chosenciphertext security. In 40th Annual Symposium on Foundations of Computer Science, FOCS ’99, 17-18 October, 1999, New York, NY, USA, pages 543–553. IEEE Computer Society, 1999. [SCO+01] Alfredo De Santis, Giovanni Di Crescenzo, Rafail Ostrovsky, Giuseppe Persiano, and Amit Sahai. Robust non-interactive zero knowledge. In Joe Kilian, editor, Advances in Cryptology - CRYPTO 2001, 21st Annual International Cryptology Conference, Santa Barbara, California, USA, August 19-23, 2001, Proceedings, volume 2139 of Lecture Notes in Computer Science, pages 566–598. Springer, 2001. [SCP00] Alfredo De Santis, Giovanni Di Crescenzo, and Giuseppe Persiano. Necessary and sufficient assumptions for non-iterative zero-knowledge proofs of knowledge for all NP relations. In Ugo Montanari, Jos´e D. P. Rolim, and Emo Welzl, editors, Automata, Languages and Programming, 27th International Colloquium, ICALP 2000, Geneva, Switzerland, July 9-15, 2000, Proceedings, volume 1853 of Lecture Notes in Computer Science, pages 451–462. Springer, 2000. [SP92] Alfredo De Santis and Giuseppe Persiano. Zero-knowledge proofs of knowledge without interaction (extended abstract). In 33rd Annual Symposium on Foundations of Computer Science, Pittsburgh, Pennsylvania, USA, 24-27 October 1992, pages 427–436. IEEE Computer Society, 1992. [Unr14] Dominique Unruh. Revocable quantum timed-release encryption. In Phong Q. Nguyen and Elisabeth Oswald, editors, Advances in Cryptology - EUROCRYPT 2014 - 33rd Annual International Conference on the Theory and Applications of Cryptographic Techniques, Copenhagen, Denmark, May 11-15, 2014. Proceedings, volume 8441 of Lecture Notes in Computer Science, pages 129–146. Springer, 2014. [Unr17] Dominique Unruh. Post-quantum security of fiat-shamir. In Tsuyoshi Takagi and Thomas Peyrin, editors, Advances in Cryptology - ASIACRYPT 2017 - 23rd International Conference on the Theory and Applications of Cryptology and Information Security, Hong Kong, China, December 3-7, 2017, Proceedings, Part I, volume 10624 of Lecture Notes in Computer Science, pages 65–95. Springer, 2017. [Wie83] Stephen Wiesner. Conjugate coding. SIGACT News, 15(1):78–88, 1983. [Zha19a] Mark Zhandry. How to record quantum queries, and applications to quantum indifferentiability. In Alexandra Boldyreva and Daniele Micciancio, editors, Advances in Cryptology - CRYPTO 2019 - 39th Annual International Cryptology Conference, Santa Barbara, CA, USA, August 18-22, 2019, Proceedings, Part II, volume 11693 of Lecture Notes in Computer Science, pages 239–268. Springer, 2019. [Zha19b] Mark Zhandry. Quantum lightning never strikes the same state twice. In Yuval Ishai and Vincent Rijmen, editors, Advances in Cryptology - EUROCRYPT 2019 - 38th Annual International Conference on the Theory and Applications of Cryptographic Techniques, Darmstadt, Germany, May 19-23, 2019, Proceedings, Part III, volume 11478 of Lecture Notes in Computer Science, pages 408–438. Springer, 2019. A A Reduction Between Unclonability Definitions A.1 In the CRS model For completeness, here we repeat the definitions of unclonability. Definition A.1. (Unclonable Security for Hard Instances). A proof (Setup, Prove,Verify) satisfies unclonable security if for every language L with corresponding relation RL, for every polynomialsized quantum circuit family {Cλ}λ∈N, and for every hard distribution {Xλ,Wλ}λ∈N over RL, there exists a negligible function negl(·) such that for every λ ∈ N, Definition A.2. (1-to-2 Unclonable Extractability) A proof (Setup, Prove,Verify) satisfies unclonable security there exists a QPT extractor E which is an oracle-aided circuit such that for every language L with corresponding relation RL and for every non-uniform polynomial-time quantum adversary A, for every instance-witness pair (x, w) ∈ RL and λ = λ(|x|), such that there is a polynomial p(·) satisfying: there is also a polynomial (·) such that q Any protocol satisfying Definition A.2 also satisfies Definition A.1. Claim A.3. . Suppose there exists a protocol Π = ( ) satisfying Definition A.2. Proof Setup, Prove, Verify Consider the extractor E guaranteed by Definition A.2. Given a sample (x, w) ← (X ,W), we will show that there is a polynomial p ′ (·) such that which suffices to contradict hardness of the distribution (X ,W), as desired. Towards showing that Equation (37) holds, recall by Definition A.2 that for every NP instance-witness pair (x, w) such that there is a polynomial p(·) satisfying: there is also a polynomial (·) such that q This implies that there is a polynomial (·) such that for every (x, w) ∈ S, q This, combined with Equation (36) implies that which proves Equation (37) as desired. A.2 In the QRO model For completeness, here we repeat the definitions of unclonability. Definition A.4. (Unclonable Security for Hard Instances). A proof ( ) satisfies unclonable security with respect to a quantum random oracle O if for every language L with corresponding relation RL, for every polynomial-sized quantum oracle-aided circuit family {Cλ}λ∈N, and for every hard distribution {Xλ,Wλ}λ∈N over RL, there exists a negligible function l(·) such that for every λ ∈ N, Prove, Verify neg Definition A.5. (1-to-2 Unclonable Extractability) A proof ( ) satisfies unclonable security with respect to a quantum random oracle O there exists a QPT extractor E which is an oracle-aided circuit such that for every language L with corresponding relation RL and for every non-uniform polynomial-time quantum adversary A, for every instance-witness pair (x, w) ∈ RL and λ = λ(|x|), such that there is a polynomial p(·) satisfying: Prove, Verify there is also a polynomial (·) such that q Any protocol satisfying Definition A.5 also satisfies Definition A.4. Claim A.6. Suppose there exists a protocol Π = (Prove,Verify) satisfying Definition A.5. Proof. Let S denote the set of instance-witness pairs {(x, w) ∈ (X ,W)} that satisfy First, we claim that Suppose not, then by Equation (41), contradicting Equation (40). Thus, Equation (42) must be true. Consider the extractor E guaranteed by Definition A.5. Given a sample (x, w) ← (X ,W), we will show that there is a polynomial p ′ (·) such that which suffices to contradict hardness of the distribution (X ,W), as desired. Towards showing that Equation (43) holds, recall by Definition A.5 that for every NP instance-witness pair (x, w) such that there is a polynomial p(·) satisfying: there is also a polynomial (·) such that q This along with Equation (40) implies that there is a polynomial (·) such that for every (x, w) ∈ S, q This, combined with Equation (42) implies that which proves Equation (43) as desired.

Unclonable Non-Interactive Zero-Knowledge: References

Previous article in this series: Running Background Tasks in Android with WorkManager: Part 3 Sending and receiving data In this article, we will look at how to pass data to a task and how to get a result. When we run a task, we may need to pass data to it and get back the result. Let's see how this can be done. Input data First, let's look at how to pass input data to the task: val myData: Data = Data.Builder()  
    .putString("keyA", "value1")  
    .putInt("keyB", 1)  
    .build()

val myWorkRequest: OneTimeWorkRequest = OneTimeWorkRequestBuilder<MyFirstWorker>()  
    .setInputData(myData)  
    .build()

  
WorkManager  
    .getInstance(this)  
    .enqueue(myWorkRequest) The data is placed in the object using its builder. Next, we pass this object to the method of the WorkRequest builder. Data setInputData When the task is running, then inside it (in ) we can receive input like this: MyFirstWorker class MyFirstWorker(context: Context, parameters: WorkerParameters): Worker(context, parameters) {  

    private val TAG = this.javaClass.simpleName  

    override fun doWork(): Result {  

        val valueA = inputData.getString("keyA")  
        val valueB = inputData.getInt("keyB", 0)  
        Log.d(TAG, "doWork:valueA $valueA")  
        Log.d(TAG, "doWork:valueB $valueB")  

        return Result.success()  

    }  

} Logs: 2023-04-20 12:44:00 29725-29754 MyFirstWorker D  doWork:valueA value1
2023-04-20 12:44:00 29725-29754 MyFirstWorker D  doWork:valueB 1 Output data For the task to return data, you must pass it to the method. The code in would be: setOutputData MyFirstWorker override fun doWork(): Result {   

        val output = Data.Builder()  
            .putString("keyC", "value11")  
            .putInt("keyD", 11)  
            .build()  

        return Result.success(output)  

    } We can get this output from : WorkInfo WorkManager  
    .getInstance(this)  
    .getWorkInfoByIdLiveData(myWorkRequest.id)  
    .observe(this) { info ->  
        when (info?.state) {  
            WorkInfo.State.FAILED -> {  

            }  

            WorkInfo.State.SUCCEEDED -> {  

                val valueC = info.outputData.getString("keyC")  
                val valueD = info.outputData.getInt("keyD", 0)  
                Log.e(TAG, "value: $valueC" )  
                Log.e(TAG, "value: $valueD" )  

            }  

            else -> {  

            }  

        }  

    } Result: 2023-04-21 08:33:20 32749-32749 WorkManagerActivity E  value: value11
2023-04-21 08:33:20 32749-32749 WorkManagerActivity E  value: 11 The Data object that stores the data has a method that will return to you a containing all the information of this . getKeyValueMap Map Data And has a method into which you can pass a , all the information which will be placed in . Data.Builder putAll(Map<String, Object> values) Map Data Data between tasks If you create a task sequence, the output of the previous task will be passed as input to the subsequent task. For example, we run a sequence of the first and second tasks: WorkManager  
    .getInstance(this)  
    .beginWith(myWorkRequest1)  
    .then(myWorkRequest2)  
    .enqueue() If the first task returns output data like this: override fun doWork(): Result {    

        val output = Data.Builder()  
            .putString("keyA", "value1")  
            .putInt("keyB", 1)  
            .build()  

        return Result.success(output)  

    } Then in the second, they will come as input and we can get them in the usual way: override fun doWork(): Result {  

    val valueA = inputData.getString("keyA")  
    val valueB = inputData.getInt("keyB", 0)  
    Log.d(TAG, "doWork:valueA $valueA")  
    Log.d(TAG, "doWork:valueB $valueB")  

    return Result.success()  

} Logs: 2023-04-21 08:53:24 628-661 MySecondWorker D  doWork:valueA value1
2023-04-21 08:53:24 628-661 MySecondWorker D  doWork:valueB 1 Let's complicate the example a bit: WorkManager  
    .getInstance(this)  
    .beginWith(listOf(myWorkRequest1, myWorkRequest2))  
    .then(myWorkRequest3)  
    .enqueue() The first and second tasks are executed in parallel, then the third one is executed. As a result, the output from the first and second tasks will fall into the third. Let's see how it turns out. Let the first task return the following data: override fun doWork(): Result {  

        val output = Data.Builder()  
            .putString("keyA", "value1")  
            .putInt("keyB", 1)  
            .putString("keyC", "valueC")  
            .build()  

        return Result.success(output)  

    } And the second one is: override fun doWork(): Result {  

        val output = Data.Builder()  
            .putString("keyA", "value2")  
            .putInt("keyB", 2)  
            .putString("keyD", "valueD")  
            .build()  

        return Result.success(output)  

    } Please note that I specifically made the same keys: and in order to check which values of these keys will come to the third task - from the first task or from the second. keyA keyB I output the input data of the third task to the log: override fun doWork(): Result {  

        Log.d(TAG, "data " + inputData.keyValueMap)  
        
        return Result.success()  

    } Result: 2023-04-21 09:04:02 783-838 MyThirdWorker D data {keyA=value2, keyB=2, keyC=valueC, keyD=valueD} In the same keys (keyA and keyB), we see that the data came from the second task. At first, I thought that this happened because the second task took a little longer than the first, and it is logical that its values would overwrite the values from the first task when the keys matched. But then I ran that sequence again and got this result. 2023-04-21 09:05:47 963-995 MyThirdWorker D data {keyA=value1, keyB=1, keyC=valueC, keyD=valueD} Now we see the values of the first task in the keys and . keyA keyB If the tasks are executed in parallel, and if the keys match, it is not known from which task you will get the value. So be careful here. InputMerger To convert multiple outputs into a single input, use . There are several implementations for this, and the default is . We have already seen how it works. If the key matches, then only one value will remain. InputMerger OverwritingInputMerger Consider another InputMerger - . If the keys match, it will create an array in which it will place all the values of this key. ArrayCreatingInputMerger Let's specify it for the third task using the method: setInputMerger val myWorkRequest3: OneTimeWorkRequest = OneTimeWorkRequestBuilder<MyThirdWorker>()  
    .setInputMerger(ArrayCreatingInputMerger::class.java)  
    .build() The will now be used when merging the output from the previous tasks into the input of the third task. ArrayCreatingInputMerger The result of its work is always an array, even if there were no key matches: override fun doWork(): Result {  

        val valueA = inputData.getStringArray("keyA")  
        val valueB = inputData.getIntArray("keyB")  
        val valueC = inputData.getStringArray("keyC")  
        val valueD = inputData.getStringArray("keyD")  

        Log.d(TAG, "valueA ${valueA?.toList()}")  
        Log.d(TAG, "valueB ${valueB?.toList()}")  
        Log.d(TAG, "valueC ${valueC?.toList()}")  
        Log.d(TAG, "valueD ${valueD?.toList()}")  

        return Result.success()  

    } Let's use the same example to test it: WorkManager  
    .getInstance(this)  
    .beginWith(listOf(myWorkRequest1, myWorkRequest2))  
    .then(myWorkRequest3)  
    .enqueue() The first task will return the following data: val output = Data.Builder()  
    .putString("keyA", "value1")  
    .putInt("keyB", 1)  
    .putString("keyC", "valueC")  
    .build() and the second one is: val output = Data.Builder()  
    .putString("keyA", "value2")  
    .putInt("keyB", 2)  
    .putString("keyD", "valueD")  
    .build() In the third, we will receive the following input data: 2023-04-21 10:22:55  2307-2340  MyThirdWorker D valueA [value2, value1]
2023-04-21 10:22:55  2307-2340  MyThirdWorker D valueB [2, 1]
2023-04-21 10:22:55  2307-2340  MyThirdWorker D valueC [valueC]
2023-04-21 10:22:55  2307-2340  MyThirdWorker D valueD [valueD] Now, when the keys match, the data is not overwritten but added to an array. Also published . here

Running Background Tasks in Android with WorkManager: Part 4

Previous article in this series: Running Background Tasks in Android with WorkManager: Part 2 Sequence of Tasks This tutorial will explore methods for running tasks in specific sequential orders. For example, say there you have a task where you want to download an archive with files, unpack it, and then process the files. This can be done with three successive tasks: download archive unpacking the archive file processing Let's see how we can run these tasks sequentially First, let's make sure that tasks started in the usual way will be executed in parallel. We start three tasks at once: val worker1: WorkRequest = OneTimeWorkRequestBuilder<Worker1>()
    .build()  

val worker2: WorkRequest = OneTimeWorkRequestBuilder<Worker2>()  
    .build()  

val worker3: WorkRequest = OneTimeWorkRequestBuilder<Worker3>()  
    .build()  

WorkManager  
    .getInstance(this)  
    .enqueue(listOf(worker1, worker2, worker3)) We look at the log: 2023-04-18 21:07:05 18984-19015 Worker2  D  doWork: start
2023-04-18 21:07:05 18984-19016 Worker3  D  doWork: start
2023-04-18 21:07:05 18984-19014 Worker1  D  doWork: start

2023-04-18 21:07:06 18984-19014 Worker1  D  doWork: end
2023-04-18 21:07:06 18984-19016 Worker3  D  doWork: end
2023-04-18 21:07:06 18984-19015 Worker2  D  doWork: end The tasks started at and were executed in parallel in different threads, and each was completed on its own time. 21:07:05 We saw parallel execution. Now let's execute them sequentially. We pass the first task to the method and thereby create the beginning of the task sequence. Next, by calling the method, we add the second and third tasks to the sequence. And using the method, we send this sequence to launch. beginWith then enqueue Result: 2023-04-18 21:28:59 20007-20036 Worker1  D  doWork: start
2023-04-18 21:29:00 20007-20036 Worker1  D  doWork: end
2023-04-18 21:29:00 20007-20044 Worker2  D  doWork: start
2023-04-18 21:29:01 20007-20044 Worker2  D  doWork: end
2023-04-18 21:29:01 20007-20045 Worker3  D  doWork: start
2023-04-18 21:29:02 20007-20045 Worker3  D  doWork: end The logs show that the tasks were performed one after another, and in the exact sequence that we indicated. How will the criteria affect the execution of the task sequence? A task that cannot currently be started will wait. And, accordingly, all other tasks that are in the sequence after this task will also wait. Let's look at an example. Let the second task have a criterion - the presence of the Internet. Turn off the Internet on the device and start the sequence. The first task doesn't care; it's running. The turn of the second task comes, but there is no Internet; so the second task is put on hold, and the third task can be started only after the completion of the second one. So it has to wait. We turn on the Internet, the second task is performed, and after it, the third one is performed. If any task in the sequence ends with a FAILURE status, the entire chain will be stopped. We can combine serial and parallel execution of tasks. WorkManager  
    .getInstance(this)  
    .beginWith(listOf(worker1, worker2))  
    .then(listOf(worker3, worker4))  
    .then(worker5)  
    .enqueue() Here we form a sequence, but at the same time, we specify two tasks for the first (beginWith) and second (first then) step of the sequence. As a result, the tasks and will be executed first, and they will be executed in parallel. After that, and will be executed, also in parallel to each other. And after that - . worker1 worker2 worker3 worker4 worker5 In the logs, it will look like this: 2023-04-18 21:41:31 20434-20464 Worker1  D  doWork: start
2023-04-18 21:41:31 20434-20465 Worker2  D  doWork: start
2023-04-18 21:41:32 20434-20464 Worker1  D  doWork: end
2023-04-18 21:41:32 20434-20465 Worker2  D  doWork: end
2023-04-18 21:41:32 20434-20476 Worker3  D  doWork: start
2023-04-18 21:41:32 20434-20464 Worker4  D  doWork: start
2023-04-18 21:41:33 20434-20476 Worker3  D  doWork: end
2023-04-18 21:41:33 20434-20464 Worker4  D  doWork: end
2023-04-18 21:41:33 20434-20465 Worker5  D  doWork: start
2023-04-18 21:41:34 20434-20465 Worker5  D  doWork: end The first and second tasks start at the same time. When they are both completed, the third and fourth start, also at the same time. When they are both completed, the fifth task starts. Let's consider another case. Suppose we need the second task to be completed after the first, and the fourth after the third. We have two sequences and they can be run in parallel. And when these two sequences are completed, you need to start the fifth task. This is how it is done: val chain12: WorkContinuation = WorkManager  
    .getInstance(this)  
    .beginWith(worker1)  
    .then(worker2)  

val chain34: WorkContinuation = WorkManager  
    .getInstance(this)  
    .beginWith(worker3)  
    .then(worker4)  

WorkContinuation.combine(listOf(chain12, chain34))  
    .then(worker5)  
    .enqueue() is a sequence of tasks. We create a sequence consisting of the first and second tasks, and a sequence consisting of the third and fourth tasks. To make these sequences run in parallel to each other, we pass them to the method. Then we pass the fifth task to the method, which starts after all the sequences from are completed. WorkContinuation chain12 chain34 combine then combine Result: 2023-04-19 15:58:20  1511-1534  Worker1 D  doWork: start
2023-04-19 15:58:20  1511-1535  Worker3 D  doWork: start
2023-04-19 15:58:21  1511-1534  Worker1 D  doWork: end
2023-04-19 15:58:21  1511-1535  Worker3 D  doWork: end
2023-04-19 15:58:21  1511-1571  Worker2 D  doWork: start
2023-04-19 15:58:21  1511-1534  Worker4 D  doWork: start
2023-04-19 15:58:22  1511-1571  Worker2 D  doWork: end
2023-04-19 15:58:22  1511-1534  Worker4 D  doWork: end
2023-04-19 15:58:22  1511-1571  Worker5 D  doWork: start
2023-04-19 15:58:23  1511-1571  Worker5 D  doWork: end The first and third tasks start, i.e. sequences start running in parallel. When both sequences are completed, the fifth task starts. Unique work We can make the task sequence unique. To do this, we start the sequence using the beginUniqueWork method. private fun work() {  

    val worker1 = OneTimeWorkRequestBuilder<Worker1>()  
        .build()   

    val worker3 = OneTimeWorkRequestBuilder<Worker3>()  
        .build()  

    val worker5 = OneTimeWorkRequestBuilder<Worker5>()  
        .build()  

    WorkManager.getInstance(this)  
        .beginUniqueWork("work123", ExistingWorkPolicy.REPLACE, worker1)  
        .then(worker3)  
        .then(worker5)  
        .enqueue()  

}

findViewById<AppCompatButton>(R.id.startWork).setOnClickListener {  
    Log.e(TAG, "enqueue REPLACE")  
    work()  
} Specify the name of the sequence, the mode, and the first task of the sequence. We specified REPLACE as the mode. This means that if a sequence with the same name is already running, then another run will cause the currently running sequence to be stopped and a new one started. I added logging to the call to the method, which starts the sequence. Let's see what's happening in the logs. enqueue 2023-04-19 16:52:32 17809-17809 WorkManagerActivity3 E  enqueue REPLACE
2023-04-19 16:52:33 17809-17882 Worker1              D  doWork: start
2023-04-19 16:52:38 17809-17882 Worker1              D  doWork: end
2023-04-19 16:52:38 17809-17914 Worker3              D  doWork: start
2023-04-19 16:52:43 17809-17914 Worker3              D  doWork: end
2023-04-19 16:52:43 17809-17952 Worker5              D  doWork: start

2023-04-19 16:52:46 17809-17809 WorkManagerActivity3 E  enqueue REPLACE
2023-04-19 16:52:46 17809-17880 Worker5              D  onStopped
2023-04-19 16:52:46 17809-17882 Worker1              D  doWork: start
2023-04-19 16:52:48 17809-17952 Worker5              D  doWork: end
2023-04-19 16:52:51 17809-17882 Worker1              D  doWork: end
2023-04-19 16:52:51 17809-17914 Worker3              D  doWork: start
2023-04-19 16:52:56 17809-17914 Worker3              D  doWork: end
2023-04-19 16:52:56 17809-17952 Worker5              D  doWork: start
2023-04-19 16:53:01 17809-17952 Worker5              D  doWork: end 16:52:32 is the first run of the sequence. Tasks start running one after another. 16:52:46 - while MyWorker5 is running, I create and start the same sequence with the same name - work123. The currently running sequence stops and a new one starts. The KEEP mode will keep the currently executing sequence running. The new one will be ignored. Code: WorkManager.getInstance(this)  
    .beginUniqueWork("work123", ExistingWorkPolicy.KEEP, worker1)  
    .then(worker3)  
    .then(worker5)  
    .enqueue() Logs: 2023-04-19 17:05:17 20030-20030 WorkManagerActivity3 E  enqueue KEEP
2023-04-19 17:05:18 20030-20207 Worker1              D  doWork: start
2023-04-19 17:05:23 20030-20207 Worker1              D  doWork: end
2023-04-19 17:05:23 20030-20227 Worker3              D  doWork: start
2023-04-19 17:05:28 20030-20227 Worker3              D  doWork: end
2023-04-19 17:05:28 20030-20272 Worker5              D  doWork: start
2023-04-19 17:05:29 20030-20030 WorkManagerActivity3 E  enqueue KEEP
2023-04-19 17:05:33 20030-20272 Worker5              D  doWork: end 17:05:29 - I tried to run the sequence again, but was ignored because there is already a sequence with the same name in the works. APPEND mode will start a new sequence after executing the current one. Code: WorkManager.getInstance(this)  
    .beginUniqueWork("work123", ExistingWorkPolicy.APPEND, worker1)  
    .then(worker3)  
    .then(worker5)  
    .enqueue() Logs: 2023-04-19 17:10:28 21636-21636 WorkManagerActivity3 E  enqueue APPEND
2023-04-19 17:10:28 21636-21730 Worker1              D  doWork: start
2023-04-19 17:10:33 21636-21730 Worker1              D  doWork: end
2023-04-19 17:10:33 21636-21784 Worker3              D  doWork: start
2023-04-19 17:10:38 21636-21784 Worker3              D  doWork: end
2023-04-19 17:10:38 21636-21836 Worker5              D  doWork: start
2023-04-19 17:10:39 21636-21636 WorkManagerActivity3 E  enqueue APPEND
2023-04-19 17:10:43 21636-21836 Worker5              D  doWork: end
2023-04-19 17:10:43 21636-21730 Worker1              D  doWork: start
2023-04-19 17:10:48 21636-21730 Worker1              D  doWork: end
2023-04-19 17:10:48 21636-21784 Worker3              D  doWork: start
2023-04-19 17:10:53 21636-21784 Worker3              D  doWork: end
2023-04-19 17:10:53 21636-21836 Worker5              D  doWork: start
2023-04-19 17:10:58 21636-21836 Worker5              D  doWork: end 17:10:39 - the current sequence was not interrupted, and a new one was launched immediately after the end of the current one. Be careful with this mode, because. an error in the current sequence may result in the new sequence not starting. I created and restarted the same sequence in these last examples, but the current and new sequences may consist of different tasks. The main thing here is the same name as the sequences.

Running Background Tasks in Android with WorkManager: Part 3

Previous article in this series: Running Background Tasks in Android with WorkManager: Part 1 Task start constraint WorkManager allows us to set the constraint for launching a task. For example, the task in question could be checking whether there’s Internet service on the device. When you pass such a task to , it will check that there is an internet connection. If there is a connection, then the task will start. And if there isn’t, then the task will hang in the ENQUEUED status until the Internet appears. WorkManager.enqueue If the task is running and the Internet is lost for some reason, the task will be stopped and scheduled again (ENQUEUED). Let's look at what constraint we can set. For example, we will use such a task. class WorkManager (context: Context, parameters: WorkerParameters) : Worker(context, parameters) {  

    private val TAG = this.javaClass.simpleName  

    override fun doWork(): Result {  

        Log.d(TAG, "doWork: start")  

        try {  

            (0 .. 10).forEach {  

                TimeUnit.SECONDS.sleep(10)  

                Log.d(TAG, "${it}, isStopped: $isStopped")  

                if (isStopped)  

                    return Result.failure()  

            }  

        } catch (e: InterruptedException) {  

            e.printStackTrace()  

        }  

        Log.d(TAG, "doWork: end")  

        return Result.success()  

    }  

    override fun onStopped() {  

        super.onStopped()  

        Log.d(TAG, "onStopped: ")  

    }  

} Loop 10 pauses and log the status. If the task was stopped, then exit with the FAILURE status. isStopped We also log the method. onStopped In the Activity, the code below is used to track the status of a task: WorkManager.getInstance(this)  

    .getWorkInfoByIdLiveData(workRequest.id)  

    .observe(this) { workInfo ->  

        Log.d(TAG, "onChanged: " + workInfo.state)  

    } setRequiresCharging (boolean requiresCharging) Constraint: The charger must be connected. : The code for adding a constraint looks like this val constraints = Constraints.Builder()  

    .setRequiresCharging(true)  

    .build()  

val workRequest: WorkRequest = OneTimeWorkRequestBuilder<MyWorker>()  

    .setConstraints(constraints)  

    .build() In , we include the setRequiresCharging criterion, create a Constraints object and pass it to in the method. Constraints.Builder OneTimeWorkRequest.Builder setConstraints setRequiresBatteryNotLow (boolean requiresBatteryNotLow) Constraint: the battery level is not lower than critical. setRequiredNetworkType(NetworkType networkType) Constraint: the presence of the Internet. We can specify what type of Internet network (NetworkType) should be used when starting the task: CONNECTED - WiFi or Mobile Data
UNMETERED - WiFi only
METERED - Mobile Data only
NOT_ROAMING - Internet must not be roaming
NOT_REQUIRED - Internet is not required setRequiresDeviceIdle (boolean requiresDeviceIdle) Constraint: the device has not been used for some time and has gone into hibernation. Works on API 23 and up. setRequiresStorageNotLow (boolean requiresStorageNotLow) Constraint: there must be free space on the device, not less than the critical threshold. addContentUriTrigger(Uri uri, boolean triggerForDescendants) Constraint: The task will run when the content of the specified is updated. Works on 24 and above. Uri API For one task, you can set several constraints at once.

Running Background Tasks in Android with WorkManager: Part 2

An important part of an application's tasks is background work. It can be downloaded or uploaded, compressed or decompressed, synchronized, etc. Once upon a time, services were designed for background work. But in , they were very limited: if the application is not active, then the service will be stopped after some time. And long before Android 8, developers started using tools like JobScheduler or JobDispatcher to run background tasks. Android 8 Firebase WorkManager allows you to run background tasks sequentially or in parallel, transfer data to them, get results from them, monitor the execution status, and run only if the specified conditions are met. It is actually very easy to use. Let's create and run a background task Add to dependencies: // (for Java only)    
implementation("androidx.work:work-runtime:$work_version") or // for Kotlin + coroutines    
implementation("androidx.work:work-runtime-ktx:$work_version") Create a class that inherits the class: Worker class MyWorker(context: Context, parameters: WorkerParameters) : Worker(context, parameters) {  

    private val TAG = this.javaClass.simpleName  

    override fun doWork(): Result {  
        Log.d(TAG, "doWork: start")  

        try {  

            TimeUnit.SECONDS.sleep(10)  

        } catch (e: InterruptedException) {  
            e.printStackTrace()  
        }  

        Log.d(TAG, "doWork: end")  

        return Result.success()  
    }  
} In the method, we are invited to place the code that will be executed. Here I just pause for 10 seconds and return , which means that everything was successful. We don't need to bother with threads, because the code will be executed on a non-UI thread. doWork Result.success Now we need to wrap in a : MyWorker WorkRequest val workRequest: WorkRequest = OneTimeWorkRequestBuilder<MyWorker>().build() allows us to set start conditions and input parameters to the task. So far, we are not setting anything, but simply creating a , to which we say that the task will need to be launched. WorkRequest OneTimeWorkRequestBuilder MyWorker has such a name for a reason. This task will be performed once. There is also a , but more on that later. OneTimeWorkRequestBuilder PeriodicWorkRequest Now you can run the task: WorkManager  
    .getInstance(this)  
    .enqueue(workRequest) We take and pass to its enqueue method. After that, the task will be started. WorkManager WorkRequest Let's look at the log: 2023-04-02 10:01:58.364 20001-20040 MyWorker D  doWork: start
2023-04-02 10:02:08.367 20001-20040 MyWorker D  doWork: end It can be seen that the task was running for 10 seconds, and the code was not running on the UI thread. Task Status WorkManager provides the ability to track the status of a task. For example, in Activity, we write: WorkManager.getInstance(this)  
    .getWorkInfoByIdLiveData(workRequest.id)  
    .observe(this) { workInfo ->  
        Log.d(TAG, "onChanged: " + workInfo.state)  
    } The getWorkInfoByIdLiveData method must pass the task ID, which can be obtained by the method. As a state, we receive LiveData, subscribe to it, and all changes in the status of our task will come to the method. Using the WorkInfo.state method we will get the current state. WorkRequest.id onChanged We launch: 2023-04-02 10:41:26.492 25791-25791 MainActivity D  onChanged: ENQUEUED
2023-04-02 10:41:26.530 25791-25826 MyWorker     D  doWork: start
2023-04-02 10:41:26.531 25791-25791 MainActivity D  onChanged: RUNNING
2023-04-02 10:41:36.531 25791-25826 MyWorker     D  doWork: end
2023-04-02 10:41:36.560 25791-25791 MainActivity D  onChanged: SUCCEEDED Immediately after calling the enqueue method, the task is in the ENQUEUED status. The WorkManager then determines that the task can be run, and executes our code. At this point, the status changes to RUNNING. After execution, the status will be SUCCEEDED, because we returned such a status in the method. The status comes to us in the UI thread. doWork Now let's run the task again and close the application: 2023-04-02 10:50:38.057 25791-25791 MainActivity  D  onChanged: ENQUEUED
2023-04-02 10:50:38.067 25791-25923 MyWorker      D  doWork: start
2023-04-02 10:50:38.071 25791-25791 MainActivity  D  onChanged: RUNNING
2023-04-02 10:50:48.073 25791-25923 MyWorker      D  doWork: end Please note that the task has been completed, but the SUCCEEDED status has not arrived. Why? Because, by closing the Activity, we just unsubscribed from LiveData, which passed us the status of the task. But the task itself has not gone away. It does not depend on the application in any way and will be executed even if the application is closed. State In our task, we returned the WorkInfo.SUCCESS status, thereby reporting that everything is ok. There are two more options: FAILURE - in this case, after the task is completed, workInfo.state will return FAILED. For us, this is a signal that the task was not completed. CANCELLED - used to indicate that the task has been canceled and will not execute. All dependent work will also be marked as CANCELLED and will not run. BLOCKED - the task is currently blocked because its prerequisites haven't been finished successfully. Cancel a task We can cancel the task with the method by passing the task ID: cancelWorkById WorkManager.getInstance(this).cancelWorkById(workRequest.id) This will call the method in the class (if you have implemented it). Also, in the class, we can always use the boolean method to check if the task has been canceled. onStopped MyWorker MyWorker isStopped If we track the status of a task, then WorkInfo.state will return Cancelled. There is also a method that will cancel all your tasks. But the help warns that it is extremely undesirable for use; it may hook the libraries you are using. cancelAllWork Tag You can assign a tag to a task using the method: addTag val workRequest: WorkRequest = OneTimeWorkRequestBuilder<MyWorker>()  
    .addTag("myWorkTag")  
    .build() You can add multiple tags to one task. WorkInfo has a method that will return all the tags assigned to this task. getTags By assigning one tag to several tasks, we can cancel all of them using the method: cancelAllWorkByTag WorkManager.getInstance(this).cancelAllWorkByTag("myWorkTag") setInitialDelay Task execution can be postponed for a specified time. In the setInitialDelay method, we indicated that the task should be started 10 seconds after it is passed to . WorkManager.enqueue Periodic task The we've reviewed is a one-time task. And if you need multiple executions after a certain period of time, then you can use : OneTimeWorkRequestBuilder PeriodicWorkRequestBuilder val periodicWorkRequest: WorkRequest = PeriodicWorkRequestBuilder<MyWorker>(30, TimeUnit.MINUTES)  
    .build() In the builder, set the interval to 30 minutes. The task will now run at that interval. The minimum available interval is 15 minutes. If you set it to less, WorkManager will automatically increase it to 15 minutes. The WorkManager guarantees that the task will run once during the specified interval. And this can happen at any point in the interval - after 1 minute, after 10, or after 29. With the flex parameter, you can limit the allowed start time range. val periodicWorkRequest: WorkRequest = PeriodicWorkRequestBuilder<MyWorker>(30, TimeUnit.MINUTES, 25, TimeUnit.MINUTES)  
    .build() In addition to the interval of 30 minutes, we additionally pass the parameter 25 minutes to the flex builder. Now the task will not be launched at any moment of the 30-minute interval, but only after the 25th minute. Those between 25 and 30 minutes.

Running Background Tasks in Android with WorkManager: Part 1

Even if you’re new to C#, you’ve probably come across at least one of Tasks, Threads, or BackgroundWorkers. With a bit of additional time, it’s likely you’ve seen all three in your journey. They’re all ways to run concurrent code in C# and each has its own set of pros and cons. In this article, we will explore how each one operates at a high level. It’s worth noting that in most modern .NET applications and libraries you’ll see things converging to Tasks. The Approach I’ve gone ahead and created a test application that . Because this is in source control, it’s possible/likely that it will diverge from what we see in this article, so I just wanted to offer that as a disclaimer for you as the reader. you can find here The application allows us to select different examples to run. I’ll start by pasting below so you can see how things work. that code using System.Globalization;

internal sealed class Program
{
    private static readonly IReadOnlyDictionary<int, IExample> _examples =
        new Dictionary<int, IExample>()
        {
            [1] = new NonBackgroundThreadExample(),
            [2] = new BackgroundThreadExample(),
            [3] = new BackgroundWorkerExample(),
            [4] = new SimultaneousExample(),
        };
    private static void Main(string[] args)
    {
        Console.WriteLine("Enter the number for one of the following examples to run:");
        foreach (var entry in _examples)
        {
            Console.WriteLine("----");
            var restoreColor = Console.ForegroundColor;
            Console.ForegroundColor = ConsoleColor.Cyan;
            Console.WriteLine($"Choice: {entry.Key}");
            Console.ForegroundColor = ConsoleColor.Magenta;
            Console.WriteLine($"Name: {entry.Value.Name}");
            Console.ForegroundColor = ConsoleColor.Yellow;
            Console.WriteLine($"Description: {entry.Value.Description}");
            Console.ForegroundColor = restoreColor;
        }
        Console.WriteLine("----");
        IExample example;
        while (true)
        {
            var input = Console.ReadLine();
            if (string.IsNullOrWhiteSpace(input))
            {
                Console.WriteLine("Would you like to exit? Y/N");
                input = Console.ReadLine();
                if ("y".Equals(input, StringComparison.OrdinalIgnoreCase))
                {
                    return;
                }
                Console.WriteLine("Please make another selection.");
                continue;
            }
            if (!int.TryParse(input, NumberStyles.Integer, CultureInfo.InvariantCulture, out var exampleId) ||
                !_examples.TryGetValue(exampleId, out example))
            {
                Console.WriteLine("Invalid input. Please make another selection.");
                continue;
            }
            break;
        }
        Console.WriteLine($"Starting example '{example.Name}'...");
        Console.WriteLine("-- Before entering example method");
        example.ExecuteExample();
        Console.WriteLine("-- After leaving example method");
    }
} Threads Threads are the most basic form of concurrent execution in C#. They are created and managed by the operating system, and can be used to run code in parallel with the main thread of execution. The concept of a thread is one of the most basic building blocks when we talk about concurrency in general for programming. However, it’s also a name of a class that we can directly use in C# for running concurrent code. Threads allow you to pass in a method to execute. They also can be marked as background or not, where a background thread will be killed off when the application attempts to exit. Conversely, a non-background thread will try to keep the application alive until the thread exits. Here is an example of creating and starting a new thread: Thread newThread = new Thread(new ThreadStart(MyMethod));
newThread.Start(); One major advantage of using Threads is that they have a low overhead, as they are managed directly by the operating system. However, they can be more difficult to work with than other concurrent options, as they do not have built-in support for cancellation, progress reporting, or exception handling. In C#, we’ve had access to the Thread object for a long time so it makes sense that other constructs have been built on top of this for us adding additional quality of life enhancements. Let’s check out : the first Thread example public void ExecuteExample()
    {
        void DoWork(string label)
        {
            while (true)
            {
                Task.Delay(1000).Wait();
                Console.WriteLine($"Waiting in '{label}'...");
            }
        };

        var thread = new Thread(new ThreadStart(() => DoWork("thread")));
        thread.Start();

        Console.WriteLine("Press enter to exit!");
        Console.ReadLine();
    } In the context of our sample application, we would be able to see the method printing to the console while the Thread is running. However, when the user presses enter, the example method would exit and then the program would also try to exit. Because this Thread is not marked as background, it will actually prevent the application from terminating naturally! Try it out and see. We can directly compare this with , which has one difference: The Thread is marked as background. When you try this example out, you’ll notice that the running thread does not prevent the application from exiting! the second example Background Workers BackgroundWorker is a higher-level concurrent execution option in C#. It is a component included in the System.ComponentModel namespace, and generally you see this used in GUI applications. For example, classic WinForms applications would take advantage of these. Let’s look at : our example for BackgroundWorker public void ExecuteExample()
    {
        void DoWork(string label)
        {
            while (true)
            {
                Task.Delay(1000).Wait();
                Console.WriteLine($"Waiting in '{label}'...");
            }
        };

        var backgroundWorker = new BackgroundWorker();
        // NOTE: RunWorkerCompleted may not have a chance to run before the application exits
        backgroundWorker.RunWorkerCompleted += (s, e) => Console.WriteLine("Background worker finished.");
        backgroundWorker.DoWork += (s, e) => DoWork("background worker");
        backgroundWorker.RunWorkerAsync();

        Console.WriteLine("Press enter to exit!");
        Console.ReadLine();
    } One major advantage of using a BackgroundWorker is that it has built-in support for cancellation, progress reporting, and exception handling. It is setup slightly different in that event handlers are registered onto the BackgroundWorker. You can additionally have a completion handler and others registered to the object. Like a Thread marked as background, the BackgroundWorker will not block the application from exiting. Tasks Want to see how Tasks factor in? Be sure to check out that details Tasks in the same way. It summarizes with a conclusion about how you may want to use each in your programs! my blog post This article first appeared on . my blog

Understanding Tasks, BackgroundWorkers, and Threads

If you are a crypto enthusiast, you must have heard of proof-of-work and proof-of-stake which are the two consensus mechanisms used to validate crypto transactions and indeed make new cryptocurrencies. All decentralized blockchain networks require validators to prove their existence on the network, and these two methods are the ways that a validator can prove their presence. The first consensus mechanism to ever be used by a blockchain was proof-of-work, and it was on the Bitcoin blockchain. However, two years later, introduced a blockchain that made use of Proof of Stake. At that point, it was a novel idea, and many people, especially Bitcoin maximalists, . Interestingly, it has only grown in popularity since then. Peercoin expected it to fail Today, proof-of-stake as a consensus mechanism is so popular that even networks like Ethereum are And it’s not hard to see why. The mechanism does have some pretty amazing benefits that make it even more attractive than proof-of-work. But is that the whole story? Is proof-of-stake just a better mechanism than proof-of-work? Or is there something else we need to know? switching to it. Proof Of Work It is easy to think of solely in terms of blockchain consensus, but it is not. It is a pretty broad concept that can be applied to any significantly complex computational system. In essence, it is a form of proof where one party proves to others, or a system, that a certain level of computational effort has been expended. Ergo, it is a way of proving that work has been done. proof-of-work In crypto, proof-of-work mechanisms take the form of difficult mathematical problems that can only be solved by computational power. In many cases, the mathematical problems start pretty easy, but over time it gets harder and harder. While it takes a lot of work for the prover to prove that work has been done, it often takes very minimal effort for the verifiers of the system to confirm the work. The idea of proof-of-work goes as when it was invented by Moni Naor and Cynthia Dwork as a way to stop denial-of-service attacks and spam. The name was coined much later in 1999 by . far back as 1993 Markus Jakobsson Proof-of-work is a very useful way of verifying transactions because it requires verifiers to have skin in the game. By making it costly to mint a coin or validate a transaction, it ensures that only parties who care about the system can have a part to play. However, it is vital to understand that the point of proof-of-work algorithms is not to prove that certain puzzles were solved. That is merely the means. The end of these algorithms is to discourage the manipulation of data by making it infeasible due to high energy requirements. Proof Of Stake Unlike proof-of-work which has its history outside blockchains, proof-of-stake is more grounded in blockchain technology. Like proof-of-work, proof-of-stake is also a way of verifying transactions on the blockchain. But instead of asking for proof of computational work done, proof-of-stake systems ask for proof of tokens staked. That is, validators can only work on the chain by proving that they have some quantity of the chain’s native token staked. This ensures that potential attackers of the chain must have a huge fraction of the tokens to make any material impact. Of course, this means that potential hackers would have to take significant losses if they were ever to validate false transactions. It also means that validators have an incentive to hold tokens, thereby creating a robust reserve for the blockchain and stabilizing prices. Proof-of-Work vs Proof-of-Stake Both consensus mechanisms have their benefits, and they also have their disadvantages. Today, a lot of blockchains make use of proof-of-work, but that might just be because the mechanism was the first popular and tested one. The fact that the protocol itself has existed since the 90s makes it, at least historically, more reliable than proof-of-stake. One thing that proof-of-work has over proof-of-stake is that it is For crypto maximalists, the more decentralized a system is, the more secure it is and the better for it. Since proof-of-work requires more computers and systems across a network to review a block, it also requires a lot more energy usage. The fact that the system runs on heavy computing means that they are and can be The fact that these networks are also so large means they are and may be unable to scale for dApps that require a lot of speed. a lot more decentralized. very expensive to run bad for the environment. slower Proof-of-stake is almost the antithesis of proof-of-work in terms of its advantages. For one, proof-of-stake since the system does not use up computational power. This also means it is better for the environment in the long run as Since it is not necessarily a large network, proof-of-stake chains are also faster than proof-of-work chains. does not require a lot of energy it uses less power. Interestingly, asides from being a way to validate transactions on the blockchain, staking in itself have a lot of benefits outside blockchain validation. Even when you stake with third-party companies, you can still earn rewards regularly by just owning the crypto and not selling it. Amazingly, some third-party stakers like offer something called liquid staking where you can also spend your tokens through a derivative while it is staked. Aside from being a way to validate transactions on a blockchain, staking can also be a way to earn easy crypto yields. It is the equivalent of accruing interest on a savings account but with way better interest. Ankr But all of this comes at a cost. Since it usually is not as decentralized, it may not be as tamper-proof as proof-of-work chains. Now, this does not mean that this mechanism is not safe. It just means that it is a lot harder to hack a proof-of-work system than to hack a proof-of-stake one. When we get down to the bones of it, both systems are quite similar. For one, both of them have dire economic consequences for people who disrupt the network. With proof-of-work, disruptors would have to expend an incredible amount of energy and resources in terms of energy bills and hardware to successfully disrupt the network. With proof-of-stake, disruptors would risk losing the value of their tokens when they validate false transactions. If they act against the interest of the network and verify a bad block of transactions, their staked tokens will be slashed. The difference between both consensus mechanisms can be described in one sentence; ease and security. Proof-of-stake is a lot easier for the validators and is a lot easier on the environment, but proof-of-work may be a fraction more secure.

What Works And What Doesn't: The Emerging Battle Between Proof-of-Work And Proof-of-Stake

Qué funciona y qué no: la batalla emergente entre la prueba de trabajo y la prueba de participación

Ce qui fonctionne et ce qui ne fonctionne pas : la bataille émergente entre la preuve de travail et la preuve de participation

क्या काम करता है और क्या नहीं: प्रूफ-ऑफ-वर्क और प्रूफ-ऑफ-स्टेक के बीच उभरती लड़ाई

機能するものと機能しないもの: Proof-of-Work と Proof-of-Stake の間の新たな戦い

O que funciona e o que não funciona: a batalha emergente entre Proof-of-Work e Proof-of-Stake

Điều gì hoạt động và điều gì không: Cuộc chiến mới nổi giữa Proof-of-Work và Proof-of-Stake

什么有效，什么无效：工作量证明和股权证明之间的新战争

The price of NFTs, especially profile-picture NFTs like CryptoPunks and Bored Ape, continuously skyrocket attracting great attention to the NFT market in the process. In addition to profile-picture NFTs, the market is made up of many other NFT types, including trading cards, generative art, and games. Each NFT type has its representative projects. The wealth resulting from the prosperity of select projects in the NFT market continues to inspire NFT collectors and newcomers to look for the next artistic breakthrough and blue-chip NFT. Also known as the "Mineable NFT," PoW NFT is a new NFT type that has the potential to ignite a new collection trend. To understand PoW NFT, we can first take a look at PoW coins. Two of the most well-known PoW coins are Bitcoin and Dogecoin. Besides, though always claiming the transfer from PoW to PoS, Ethereum - besides always claiming a transfer from PoW to PoS, is strictly a PoW coin. Despite the fact that the cryptocurrency market is full of scam tokens like ERC-20 and BEP-20, according to data from crypto state, the PoW coins account for over 60% of the entire market. In a nutshell, PoW coins are mineable coins that use the proof-of-work consensus algorithm to generate new blocks on the blockchain. It requires miners to perform hash rate calculations on machines - a process known as mining. CPUs and GPUs are no longer the machines used to mine PoW coins, today professional ASIC miners are used. These changes mainly resulted from miners' pursuit of efficiency and cost control after PoW coins have scaled up. Therefore, we can understand PoW NFT as a product of miners using machines to mine NFTs, rather than coins or using the proof-of-work consensus algorithm to generate new NFTs on the blockchain. PoW is important in cryptocurrency. Bitcoin uses PoW as its consensus protocol to realize distributed ledger and ensure the security of the ledger. At the same time, PoW provides added fairness to the distribution of Bitcoin. After more than ten years of development, Bitcoin has formed a stable production cost on a global scale because of the PoW mechanism. As a result, its relatively stable price and investment-profit matrix contribute to miners' faith in becoming long-term holders. Likewise, PoW's importance also applies to Ethereum and Dogecoin. PoW is extremely important for cryptocurrency in terms of market value, technology, security, fair distribution in the early stage, and the formation of long-term sustainability. It can be concluded that cryptocurrency cannot last without the PoW mechanism. One may wonder if PoW is just as important to NFTs as it is to cryptocurrency? What makes PoW NFT valuable? The rest of this article will center on these questions and explore answers to them. The article consists of 3 parts: A brief history of PoW and PoW NFT Representative PoW NFT projects: 2.1 PoW NFT on Ethereum: MoonCatResecure、Atom、MineablePunks 2.2 PoW NFT on Hacash: Hacash Diamond The value and future of PoW NFT 1. A brief history of PoW and PoW NFT To understand the emerging market of PoW NFT, we must first understand what PoW is. PoW is short for Proof-of-Work. It's an economic countermeasure against service and resource misuse or Denial of Service(DoS) attacks. Users are required to perform some complex operations that consume a moderate amount of time. The answers can be quickly verified by the service provider. The time, equipment, and energy consumed are used as guarantee costs to ensure that services and resources cater to real needs. This idea was first proposed by Cynthia Dwork and Moni Naor in an academic paper in 1993 and the term PoW was invented by Markus Jakobsson and Ari Juels in 1999. The earliest use case for the PoW mechanism was Hashcash created by the current BlockStream founder, Adam Back. Hashcash was later used by Satoshi Nakamoto in designing Bitcoin's mining scheme. At the bottom of Bitcoin’s white paper, it cites Hashcash as the sixth position. We can trace PoW NFT's origin to Crypto trading cards in 1993. It was proposed by Hal Finney, most likely by Bitcoin’s creator Satoshi Nakamoto. It is also widely recognized as the earliest NFT prototype. Although the Crypto trading card was not really implemented at the time, we can infer that each card's hash was not randomly generated with equal probability, otherwise, there would be an unlimited number of cards with identical value. As a result, these cards could have collection value only if their hash conforms to a certain established rule, such as the fixed PoW difficulty. If there are no established rules for generating effective hash, the potential number of crypto trading cards is infinite, and collectible crypto trading cards must have some kind of rare hash value result. For example: “000000000000007f8c5aba11cf3b5e67a2” “d01e14a7f8c5aba11cf3b025285e67a26687” The first one will be more collectible than the second because it is "good-looking." Such a well-organized hash is derived from PoW computation, greater hash power will result in a "better-looking" hash number. Then the Crypto trading cards mentioned by Finney, in every respect, must be PoW, otherwise, they will have no value for collection, transaction, and circulation. In 1998, Nick Szabo, the father of the smart contract, invented Bit Gold, which was an expensive encrypted gold that is computed using electricity. The first key property of Bit Gold is PoW: a proof of value derived from consuming hash power. For Bit Gold, a valid hash must follow some patterns, such as the number of leading zeros in the hash result. Due to the unpredictability involved in generating hash, the only way to find a valid hash is to compute it over and over again until we find a valid one. Such a valid hash serves as proof that its owner actually consumed computing power to find it and anyone who finds a valid hash will own it. Since each Bit Gold is represented by a unique hash, the cost of computing the hash and deriving the Bit Gold varies, resulting in different values. But Bit Gold's "unchanged difficulty" for deriving valid hash leads to inflation. As hash value increases and computers improve, it will become easier to generate a valid hash and its value will be diluted by an oversupply of valid hashes. Bit Gold is a typical PoW NFT. But it is not an NFT worthy of collection because it does not solve the core problem of inflation caused by "unchanged difficulty." 2. Representative PoW NFT projects We investigated exemplary PoW NFT projects available in the market. These NFTs can be divided into two categories: primitive PoW NFTs on non-smart-contract chains, and PoW NFTs on smart-contract-supported chains. Currently, PoW NFTs that support smart contracts are all only on the Ethereum chain, and PoW NFTs on non-smart-contract chains are only on the Hacash chain. 2.1 PoW NFT on Ethereum: MoonCat、Atom、Mpunks There are three main PoW NFTs on the Ethereum chain: MooncatRescue(MoonCat), PoW NFT (Atom), and Mineable NFT (Mpunks). PoW NFT and Mineable NFT are their real names. The group running these two projects might also have realized that PoW NFT was a potential market in its early stage, so they took these names in advance. But it can be verified by the blockchain that these two projects are not the earliest PoW NFTs. In this article, we will refer to them as Atom and mpunks respectively. MoonCatRescue(MoonCat) , also known as MoonCat, is a classic NFT after CryptoPunk. The first MoonCat was born on August 10, 2017. Moon Cat was developed by two creators, collectively known as Ponderware. MoonCatRescue Strictly speaking, MoonCat is not a PoW NFT. It uses the CPU mining mechanism for production. You can find a MoonCat in a few seconds or minutes by connecting your Ethereum wallet to the website and searching with a CPU. This process does not consume too much hash power, because it is just a simple "generating algorithm". This seemingly simple approach contributes to the birth of PoW NFT: fair distribution, open for everyone to mine, unpredictable style before an NFT is mined. Therefore, PoW NFT is generative art in the NFT market. PoW NFT(Atom) The first PoW NFT project on Ethereum centers on Atom and is named . In order to distinguish this project from the PoW NFT category, we refer to it as Atom in this article. PoW NFT The founders of Atom claimed that it is the first PoW NFT by definition, but the first Atom was generated on March 12, 2021. Similar to Mooncats, Atom can also be produced by connecting the Ethereum wallet to the website and searching Atoms with a CPU. But it takes no longer than just a matter of seconds to minutes to find an Atom because the "mining difficulty" is not fixed. Theoretically, the total amount of Atom is infinite. But after more than 40,000 Atoms are mined, it will be difficult to produce an Atom. That is, the difficulty of mining will go up with the number of Atoms mined. In each new cycle, the difficulty will increase by 3 times and the production time will also triple on average. Since there is no upper limit on the number of Atoms, the difficulty will surge in the 14th cycle (starting number #16384), and it would be infinitely difficult to mine an Atom. So the #16384 Atom is technically the last Atom that can be mined. Besides, the mining cost also doubles in each cycle, and the current cost of mining an Atom is 0.18ETH. Depending on the configuration of the computer, the average time of producing an Atom varies. Experiment shows that it takes 1 minute for a laptop to mine the #258 Atom, and 1 hour for the #2048 Atom on average. After in #8192, the average time needed jumps to about 6 hours. Unlike MoonCat, different Atoms vary in atomic elements and mining difficulty. However, Atom's mining difficulty does not change continuously, resulting in Atom production being monopolized by miners of large hash power. Due to the discontinuous mining difficulty, Atom production can become unpredictable and Atom price can fluctuate uncontrollably. At this time, the market is on the verge of collapse. Mineable NFT(Mpunks) has changed its name to Mineable NFT. Because the group running the project has created two different Mineable projects to increase Mpunks' liquidity, it uses two names to differentiate the two projects. Mpunks Mpunks mainly consist of CryptoPunk. Theoretically, there can be many CryptoPunks, but Larva Labs limits the number to 10,000. The remaining CryptoPunks in addition to the 10,000 ones, however, can be delivered through mining. The mining difficulty of Mpunks continues to increase. Like Atom, Mpunks can be monopolized by miners of great hash power. The fact that every 33 Mpunks mined would result in one Mpunk going to the founder further upsets some Mpunks collectors. Imagine how the Bitcoin miners feel if the community has to give a Bitcoin to Satoshi Nakamoto each time after 33 Bitcoins are mined. Another risk lies in Mpunks' copyright. But Mpunks collectors hope Larva Labs will sue Mpunks for copyright infringement because it's also a good sign for them. It can be expected that if the PoW NFT market becomes popular, various PoW NFT projects will emerge, such as mineable BAYC, mineable Noodles, and mineableBlockArt. Should this happen, interested collectors who have missed CryptoPunk or BYAC will have a more fair way to own their PoW version. 2.2 PoW NFT on Hacash: Hacash Diamond(HACD) Hacash Diamond is different from the three PoW NFTs on the Ethereum blockchain above. It is on a blockchain called Hacash. The Hacash White Paper was published by an anonymous author on the internet in 2018 and subsequently was used to develop the Hacash ecosystem by developers in the Hacash community. The first Hacash Diamond was mined on May 16, 2019. HACD is short for Hacash Diamond. Each HACD is represented by 6 special letters from the set of letters "WTYUIAHXVMEKBSZN" so that the total amount of HACD is limited to 16 ^ 6 = 16,777,216. And each HACD varies in shape and color. HACD's total amount is very large compared to the PoW NFT projects mentioned above, and its mining difficulty also constantly rises like Atom and Mpunks. But the mining difficulty increases smoothly and continuously, allowing miners to accurately estimate the time and hash power needed to mine a HACD. In terms of a sustainable ecosystem, the number of miners in the HACD community rises at a stable rate. Most interestingly, after each Hacash Diamond is produced, miners need to bid for the diamond. It should be the first example of miners participating in auctions in the cryptocurrency world. Compared to other PoW NFTs, this bidding mechanism has four significant benefits: The production of HACD per unit time is controllable and has an upper limit. While the continuous increase in mining difficulty contributes to stable demand and supply in the long term, the bid mechanism helps dynamically adjust demand-supply conditions in the short term. Note that a higher bid implies a greater demand. While the time spent on mining determines the validity of HACDs, bid mechanism determines which HACD is valid at the end of a cycle. Transparent bid cost helps collectors evaluate the value of a Hacash Diamond that they are collecting. The biggest problem is that HACD is not an NFT on the Ethereum blockchain and as such, a third party needs to be involved to guarantee the transaction for each listing on the Opensea or other NFT marketplaces. 3. PoW NFTs' Value and Future The core use case of PoW NFT must be the same as Bitcoin, i.e a store of value. If that is the case, then the three elements that measure good store of value pricing, stored value, and liquidity can also measure a PoW NFT collectible. The pricing level is referenced by the mining and bid cost, the stored value level is converted from energy, and the liquidity is provided by a certain number of NFTs with similar features. From MoonCat, Atom, Mpunks, and HACD, we can foresee the great value and potential of PoW NFT in the future. 1. Fair Production Traditional NFTs are produced by smart contracts on the Ethereum blockchain. With all things being equal, robots are more likely to find and mint an NFT ahead of you. Even after the white list came out, the majority of the collectors still have problems minting an NFT in the early stage. NFTs mined with the PoW mechanism can solve this problem and ensure fair production of NFTs, because the production mainly depends on the amount of hash power. Like the early Bitcoin, the general PoW NFT is mined with CPU and it requires greater hash power to mine as the blockchain's hash power increases. Such Bitcoin-like production is fairer. However, a continuous increase in mining difficulty and a bidding mechanism is necessary to prevent NFTs from being completely monopolized by miners of large hash power. 2. Quantity / Scarcity All NFT projects basically emulate Cypherpunks and limit their NFTs in circulation to specific numbers. Just like many people don’t understand why the number of Bitcoin in circulation is limited to 21M, the number of NFTs needed in circulation is also a mystery. The NFT issuers have intentionally intervened in the number of NFTs to create scarcity. The PoW mechanism allows the NFT to dynamically adjust its production to meet the market demand in the long run. When there is a shortage of the PoW NFTs, the miners can stop producing. In addition to this, the bidding mechanism can balance the demand and supply in the short run. Note that a rise in bid implies a greater demand for the NFT. 3. Art Form: Energy Generative Art Beeple's Everydays is one example of NFT artwork. The uniqueness of such artworks is fulfilled by being an NFT stored on blockchains. As the NFT technology develops, more advanced NFT art forms have emerged. For example, the small balls of Pak can interactively merge with other small balls into a larger ball. Therefore, the art form of PoW is by nature generative art, because it is nearly impossible to mine all PoW NFTs at the same time and know the look of all the NFTs in advance. Each PoW NFT is a blind box for miners. PoW NFT's art form is similar to the famous on-chain generative art, ArtBlock. But there is another name for such an art form--energy generative art. The four PoW NFT projects above all generate figurative works, namely cats, atoms, CryptoPunks, and diamonds. If ArtBlock is combined with PoW, ArtBlock's value can be numerically evaluated. 4. Long-term Sustainability The NFT market can attract great attention through celebrity endorsement and publicity. Though attention can help make a quick profit, it can not help build broad, long-term sustainability, which is necessary for the development of a high-quality collection. PoW NFT's production requires certain investments, including electricity and equipment. These absolute costs contribute to a stable NFT price and help buyers evaluate the value of the NFT. Most NFTs continuously slide down from birth and are short-lived. But PoW NFT does not have the problem of sliding down and perishing quickly. It is more suitable for long-term holding than most profile picture NFTs. Coupled with the increasing mining difficulty and bid mechanism, PoW NFT's marginal cost of production can constantly rise in the long run, and it can always dynamically adjust its production to reach supply-demand equilibrium. These features are conducive to long-term investment by miners and long-term holding by collectors, helping form long-term sustainability. Whether long-term sustainability can be established should be the most important factor to evaluate whether an NFT is worth collecting. Conclusion Compared with PoW coins’ over 60% market share, PoW NFTs are still in the early stage of NFT development. And HACD is undoubtedly a leading project in the PoW NFT market with its mature mechanism. But its problem is that it is not on the Ethereum blockchain, which will inevitably slow down its development. I believe that the rise of PoW NFT relies on the celebrity effect. HACD can expand its influence by cooperating with a well-known public blockchain or attracting famous artists to design new HACD-like PoW NFTs on a well-known public blockchain. We look forward to a breakthrough in PoW NFTs brought by these two approaches in the future. References [1]Wikipedia. (n.d.). Proof of work. Retrieved March 27, 2022, from https://en.wikipedia.org/wiki/Proof_of_work [2] Bit Gold (2005, December 29). Nick Szabo. https://nakamotoinstitute.org/bit-gold/ [3] PoW-Based NFTs in 2021: A Comparison (2021, October 15). Ken You. https://hackernoon.com/pow-based-nfts-in-2021-a-comparison

Why PoW NFTs are the Next Blue-Chip NFT Collections

A Summary and Review of The Ethical Algorithm

Hey Hackers! I’m Roxana Murariu and I’m a Senior Software Engineer at . Spencer Stuart First of all, a huge thank you to the HackerNoon community and staff for nominating me for a 2021 Noonies award! I've been nominated in the following categories, please do check out these award pages and vote: HackerNoon Contributor of the Year – CREATIVITY HackerNoon Contributor of the Year - DESIGN-THINKING HackerNoon Contributor of the Year – LIFE HackerNoon Contributor of the Year - LIFE-LESSONS HackerNoon Contributor of the Year – PHILOSOPHY Learn more about my thoughts and opinions on tech and my journey in the tech industry via the interview below. 1. What do you do and why do you do it? (tell us your story) I work as a senior software engineer for Spencer Stuart in their Dublin office, where I use many interesting front-end technologies. It is a fast-paced environment with supportive colleagues and lots of growth opportunities. 2. Tell us more about the things you create / write / manage / build! I write articles on about parenting, self-improvement, or tech essays. Writing is rewarding as I learn things I would never have thought to research on my own. my site For example, , the Zen concept of adopting the attitude and mindset of a novice who learns a new practice for the first time, led me to Plank's principle, "Science progresses one funeral at a time." researching Shoshin Or, as Max Plank himself explained: An important scientific innovation rarely makes its way by gradually winning over and converting its opponents: it rarely happens that Saul becomes Paul. What does happen is that its opponents gradually die out, and that the growing generation is familiarized with the ideas from the beginning: another instance of the fact that the future lies with the youth. But what I found absolutely intriguing is that did research how the premature deaths of star scientists working in the life sciences affect the respective field literature. What was discovered was in line with Planks’ principle, unfortunately. Collaborators of star researchers publish fewer papers in the fields after their prominent colleague's death, and the flow of articles by non-collaborators increases drastically. "It's just that, once safely ensconced at the top of their fields, maybe they tend to overstay their welcome." a study "The conclusion of this paper is not those stars are bad," says Pierre Azoulay, the study co-author. Another project is a collaboration with my husband. We will create a video game written in Unity, a story-driven fantasy role-playing game with collectible card elements. 3. How did you end up on your current career path? Do you like it? I studied informatics at the Informatics Liceum Grigore C. Moisil from Iasi, Romania. Then, I enrolled at the Faculty of Informatics in Iasi. There were some moments when I thought to switch careers, but looking back over what I achieved with and through my work, being a software developer is the right career for me right now. As I am most interested in front-end technologies, I suffered from JS frameworks fatigue when building software felt like building castles on quicksands. Now I am more at ease with the sustained rhythm of front-end development as on the one hand, the front-end ecosystem matured and on the other hand, I only follow a few trusted front-end news outlets. 4. What tech are you most excited or passionate about right now and why? Quantum computing has immense potential by allowing scientists to solve currently unsolvable problems, targeting various domains such as cryptography, finance, pattern matching, or medical research. I want to learn more about this domain, and I intend to spend some time during the holiday season reading about it. 5. What tech are you most worried about right now and why? Every week there is another new thing to worry about: the development of the COVID-19 pandemic, social and racial injustice, the attack on privacy and societies from social networks, wars, AI job automation that I wrote in . another HackerNoon article I finished , the 2020 winner of the  Nobel Prize in Chemistry, alongside Emmanuelle Charpentier, for their groundbreaking work on CRISPR gene editing technology. This technique allows editing parts of the genome by removing, adding or altering sections of the DNA sequence. The implications of gene editing are profound as it might help treat genetic diseases, including cancer, save endangered species, or innovate the biofuel industry. Walter Isaacson's biography of Jennifer Doudna As Isaacson notes in his book, The reason that CRISPR is the most important discovery since DNA's structure is that it not only describes the world, as we did with the double helix, but makes it easy to change the world. Unfortunately, there is a dark side to gene editing. Feng Zhang, a biochemist well known for his role in the development of CRISPR technologies, says in Isaacson's book: Look at what parents are willing to do to get kids in college. Some people will surely pay for genetic enhancement. In a world in which there are people who don't get access to eyeglasses, it's hard to imagine how we will find a way to have equal access to gene enhancements. Imagine what that will do to our species. At its worst, gene editing could aggravate and even encode social inequality. But above all, the tech question that terrifies me the most is that we might not be moving the needle fast enough to combat climate change. Millions are at risk of displacement as areas will become uninhabitable. Then, we have water wars, drought, famine, wildfires and so on. Of course, things are not entirely desperate. Look how far we have come in the last decades due to technological discoveries. Gene editing could bring drought-resistant and disease-resistant crops that will be significant advantages against food scarcity. Then, we also have better technology to predict storms, floods, wildfires. Some voices suggest that through modelling better catalysts for carbon capture. quantum computing can be used to help environmental efforts So, I won't end this question negatively, and I will leave about hope in the face of climate change. this fantastic article 6. If we gave you 10 million dollars to invest in something today, what would you invest in and why? If only! I took this question to my husband, and I was delighted to find out that we would both do the same thing. First, a large part of the sum would go into our business to develop the stories we have in mind faster. The rest of the money would go to donations to fight poverty and offer better education to children. I was impressed by the book written by Esther Duflo and Abhijit Banerjee, y, describing their approach to fight poverty through scientific evidence. Poor Economics: A Radical Rethinking of the Way to Fight Global Povert They ran hundreds of randomized controlled trials to find which method yielded better results. For example, they discovered that deworming children in Kenya for two years could bring thousands of dollars PPP lifetime income gains. Minor investments in childhood nutrition (in Kenya, deworming costs a few dollars per year per person) can produce significant ROI. I fully agree with Esther's opinion quoted below, and I would donate money to the Poverty Action Lab she co-founded: It is very easy to sit back and come up with grand theories about how to change the world. But often, our intuitions are wrong. The world is too complex to figure everything out from your armchair. The only way to be sure is to go out and test your ideas and programs and to realize that you will often be wrong. But that is not a bad thing. It leads to progress. A quote of Esther Duflo from Matthew Syed’s book, Black Box Thinking 7. What are you currently learning? I recently gave a technical presentation about , a state management library for Angular, to my colleagues. It was a perfect opportunity to scour the Ngrx Github code and see this library in a new light. NgRx 8. What’s the best advice you’ve ever given someone? If we didn't acquire the mental models that let us perceive a situation differently, words would fall on deaf ears. So, I learned that sometimes, people are not looking for advice but a reinforcement of their position. Nevertheless, I started writing , and I would say that my articles on and might be some of my better advice. a series of letters to my daughter building a “f*ck-off” fund how to choose a career strategically 9. What’s the best advice you’ve ever received? The illiterate of the 21st century will not be those who cannot read and write, but those who cannot learn, unlearn and relearn. writer and futurist Alvin Toffler It is remarkable how Alvin Toffler predicted in the 1970s this trend of reinventing ourselves periodically through learning, unlearning, and relearning. Especially for software engineers, if we don't systematically re/up-skill, we are condemned to become irrelevant. I use this quote as a reminder to employ a beginner's mindset, ask better questions and challenge my preconceptions and biases. About HackerNoon’s 2021 Noonie Awards The annual Noonie Awards celebrate the best and brightest of the tech industry, bringing together all who are making the Internet and the world of tech what it is today. Please be sure to , nominate, and vote for the people and companies who you think are making the biggest impact on the tech industry today. check out our award categories The 2021 Noonies are sponsored by: , , and . Thank you so much to these sponsors who are helping us celebrate the accomplishments of all our nominees. bybit Dottech Domains Avast

Stories, News & Mentions about DEWORK

Dework’s Stories on HackerNoon