Apsy has unveiled the pioneering AI-powered app builder, enabling users to transform their ideas into functional apps just by speaking their minds, guided by the AI for customization

Apsy

apsy

Welcome to HackerNoon’s interview series. This section is curated by our Editorial team to spotlight bold and disruptive startups across the globe. If you’ve been nominated, and answer these questions Startups-Of-The-Year create a brand profile here. Hey Hackers, Apsy has been nominated in HackerNoon's annual Startup of the Year awards in Los Angeles, US. Please vote for us . here Read more about us below to understand why we deserve your vote. Meet Apsy Our start-up is called , a cool name rooted in Apps, but to us, it means “making app-building a breeze!” We are the first to introduce a fully AI-powered app builder. Our users speak their minds as our AI builds them. Apsy What makes us a different startup from others who offer tools to build apps is that we're all about letting your ideas flow while our AI does the heavy lifting. You dream it, speak it, and our AI builds it. Unlike traditional DIY tools, we take care of all the techy stuff, so our users don't have to. With Apsy, your creativity is the only limit. My Role Tooraj, a double Ph.D. dynamo in Economics and Computer Science, is a seasoned tech exec with a penchant for AI algorithms. A Y-Combinator and Techstars alumni is now driving his second startup, Apsy, towards reimagining software development. With a vision to make it simpler and cost-effective through AI, Tooraj is steering tech's future. How We're Disrupting/Improving the app development industry Building an app with traditional methods feels like a tough mountain to climb, right? But at Apsy, we're turning that hike into a fun walk in the park! Just chat with our AI about your brilliant app idea, answer a few clever questions it throws at you, and ta-da! Your app is up and running in a snap - we're talking hours, not months! We're shaking up the app-making game, making it a piece of cake for everyone, not just the coding wizards. Apsy isn't just transforming app development but the whole software landscape and tech entrepreneurship. Exciting times are ahead! Standing Out from The Crowd Do you remember how difficult building an app was in the good old days? Costly developers, scary DIY journeys, and months of learning only to end up with an 'okay-ish' app. Well, not anymore! We Apsy all you need to do is share your big idea, answer a few questions from our smarty-pants AI, and boom! It starts crafting screen options for you. And the best part? You can add your finishing touches and have a fabulous, tailor-made app ready to shine in just a few hours. And all this without burning a hole in your pocket! Building an app has never been this fun and easy, right? Our Predictions/Thoughts on the App Development Industry in 2023 The tech industry, specifically app development, is experiencing a significant shift towards no-code and low-code solutions. However, their complexity often presents challenges. Here, AI-driven platforms like Apsy come into play, simplifying app creation without needing users to be coding experts. As we move further into 2023 and beyond, we predict a surge in AI integration into app development owing to the rising demand for rapid, cost-effective digital solutions. The growth of AI sophistication will enable a better understanding of user needs and the delivery of high-quality, personalized apps. This AI infusion will transform the technological landscape and democratize the digital space, fostering innovation and promoting tech entrepreneurship. As Apsy, we're excited to pioneer this transformative journey, making app development more accessible and enjoyable. What word defines the state of app development in 2023? If you're asking about the vibe of app development in 2023, it's all 'Mind-to-Machine'! Just picture this - you come up with a killer app idea, chat about it, and voila, our AI buddy gets it done. No fuss, no code, just pure creativity! This exciting 'Mind-to-Machine' era is giving everyone the power to turn their app dreams into reality. It's like having a chat with a friend who happens to be a coding genius. So, buckle up, folks! We're on a fun-filled, game-changing journey that's turning the tech world on its head! Why we decided to participate in HackerNoon's Startup of the Year awards We jumped into HackerNoon's Startup of the Year awards because we're shaking things up with our 'Mind-to-Machine' tech at Apsy and wanted to share this cool innovation with fellow tech enthusiasts. Plus, who doesn't love a good challenge? We saw it as a great chance to learn, grow, and have some fun while competing with other innovative startups. So, here we are, all set to dazzle at the awards. Fingers crossed, folks! Final Thoughts At Apsy, we're on an exciting mission in 2023, transforming app development and making it accessible for all. We're thrilled to bring our innovation to HackerNoon's Startup of the Year awards, showcasing our approach, learning from peers, and embracing challenges. So, we invite you to on this thrilling journey, where we'll turn dreams into digital realities together! join us Don’t forget to ! Vote for us today

Vote for Apsy in HackerNoon's Startups of the Year 2023

To help researchers and developers in academia and beyond, Alibaba has now published its Cluster Data V2018 for all to explore In IT articles about internet applications, you will often find words such as “large scale” and “mass requests”. These applications all run in large-scale data centers, and readers generally have many questions about those environments. For example, what is the operating status of each machine in the data center? What kinds of applications are running? What are the characteristics of these applications? With the exception of a few senior experts, it is rare for students and corporate researchers to understand these details. Today, Alibaba shares a real dataset for computer clusters: (attached at the end of article). This dataset provides a full record of details for the servers and running tasks in Alibaba’s production cluster. With the release of this data, Alibaba hopes to engage its peers in academia and the wider industry and to promote further development within the industry. Alibaba Cluster Data V2018 Drawing on insights from Lin Shi, a technical expert at the Ali System Software Division, this article offers an in-depth introduction to this unique dataset, as well as findings from academic research with the previous year’s data. Releasing the Dataset: A Resource for Exploration In 2015, Alibaba tried to deploy latency insensitive batch computing tasks and latency sensitive online services to the same batch of machines in its data center, with the goals of allowing redundant resources to be fully utilized and improving the overall utilization of these machines. After more than three years of trial demonstrations, structural adjustments, and optimization of resource isolation, this program has now moved into the mass production phase. Average resource utilization of clusters has since increased from 10% to 45% using colocation technology (i.e. the technology that allows running online service and batch workloads on same machine). In addition, through various optimization methods, more tasks can now be run in the data center, and the average transaction cost of the 11.11 Global Shopping Festival has been reduced by 17% per 10,000 transactions. Though some readers will understand this achievement and how it was accomplished, many are likely to have questions such as what exactly the computer cluster looks like after optimization, or what colocation means and why it matters. In releasing the Alibaba Cluster Data V2018 dataset, Alibaba hopes to help interested students and researchers answer those questions and better understand large-scale data centers. Using the dataset, individuals can learn more about how Alibaba has increased resource utilization to 45% via colocation; how many tasks Alibaba runs each day; and what the resource requirements of the business are. How individuals use this dataset depends entirely on their needs. Making Use of the Data At 50 GB compressed and 270 GB uncompressed, Alibaba Cluster Data V2018 is a large dataset with many different uses. In six files, it has data for 4000 servers, corresponding online application containers, and operation of offline computing tasks for up to eight days. With Alibaba Cluster Data V2018, individuals can do the following: · Understand the servers and the characteristics of running tasks in today’s advanced data centers. · Experiment with various algorithms for task management and cluster optimization in scheduling and operations, and write papers about them. · Use the data to learn how to conduct data analysis, and reveal more techniques and methodologies that have not yet been discovered. The following are examples of questions the data can be used to answer: · E-commerce businesses face different pressures during daytime and nighttime. How can we improve overall resource utilization with these peaks and valleys? · How many dependencies does Alibaba’s longest DAG have? · How long does a container typically exist? · What is the typical lifetime of a computational task? · Multiple instances of a task are theoretically similar to each other, but do they all run at the same time? In fact, academics have already used Alibaba cluster data for a range of crucial analysis and research. In 2017 and 2018, a number of prominent academic papers were published based on of the first wave of data shared in Alibaba Cluster Data V2017. The following sections show examples of academic uses of the dataset, many of which have been featured in academic conferences such as OSDI. LegoOS: A Disseminated, Distributed OS for Hardware Resource Disaggregation — Yizhou Shan, Yutong Huang, Yilun Chen, and Yiying Zhang; Purdue University. (OSDI’18 Best Paper Award recipient) Imbalance in the Cloud: An Analysis on Alibaba Cluster Trace — Chengzhi Lu et al. (BIGDATA 2017) Characterizing Co-located Datacenter Workloads: An Alibaba Case Study — Yue Cheng, Zheng Chai, Ali Anwar. (APSys2018) The Elasticity and Plasticity in Semi-Containerized Co-locating Cloud Workload: a View from Alibaba Trace — Qixiao Liu and Zhibin Yu. (SoCC2018) Looking Forward: Updates in V2018 There are two major differences that distinguish the new V2018 dataset from the previous year’s V2017 dataset featured in the above research. First, the V2018 dataset includes the DAG information of some of our production batch workloads. This means that offline computing tasks like those commonly used in Map Reduce, Hadoop, Spark, and Flink are arranged in the form of a Directed Acyclic Graph (DAG), which shows parallelism, dependencies between tasks, and so on. As such, this dataset is the now the largest available DAG dataset from an actual production environment. The following figure illustrates and example of a DAG: Second, the V2018 dataset is considerably larger in scale than the previous set, which contained data for approximately 1300 machines over a 24-hour period. The new version includes data for 4000 machines over a period of 8 days. With so much having been accomplished using V2017 dataset, Alibaba looks forward to the developments to come as researchers begin work with the new dataset in 2019. (The original article is written by Ding Haiyang丁海洋) Alibaba Cluster Data V2018 Download link: [machine_meta]( http://clusterdata2018pubus.oss-us-west-1.aliyuncs.com/machine_meta.tar.gz) [machine_usage]( http://clusterdata2018pubus.oss-us-west-1.aliyuncs.com/machine_usage.tar.gz) [container_meta]( http://clusterdata2018pubus.oss-us-west-1.aliyuncs.com/container_meta.tar.gz) [container_usage]( http://clusterdata2018pubus.oss-us-west-1.aliyuncs.com/container_usage.tar.gz) [batch_task]( http://clusterdata2018pubus.oss-us-west-1.aliyuncs.com/batch_task.tar.gz) [batch_instance]( http://clusterdata2018pubus.oss-us-west-1.aliyuncs.com/batch_instance.tar.gz) Alibaba Tech First hand and in-depth information about Alibaba’s latest technology → Facebook: . Twitter: . “Alibaba Tech” “AlibabaTech”

Open Season for Research: Alibaba Releases Cluster Data from 4000 Servers

Virtual Meetings have become an essential part of corporate collaboration, serving as the de facto way that ideas are exchanged, decisions are made, and strategies are devised. However, the true value of meetings is often diluted by their length and the complexity of the discussions. This is why note-taking and effective summaries and action points are so important. Converting long and often pointless discussions into short (actionable) summaries, meeting attendees can quickly catch up on meetings they missed, review decisions that were made, and understand discussions without having to sift through hours and hours of recordings. We thought it would be cool to create our summarizer. If you don't have one already, keep reading. This technical tutorial will guide you through creating a simple web application that summarizes daily meeting Transcripts using ApyHub’s AI Summarize Document API using NodeJS. Pre-requisites: Access to Google Meet and permission to access meeting transcripts.
A preferred programming language environment (e.g., Python).
ApyHub Account.
GitHub CLI is installed on your computer. Step 1: Clone the GitHub repository Open your terminal and run this command: git clone https://github.com/iamspathan/AI-Transcript-Summarizer.git This command will clone the project in your local environment. Once the project is cloned, you can open the repository in the code editor. Step 2. Install Required Packages: Here, in Node Package Manager (npm), we will install all the dependencies that our application needs to summarize the meeting transcribe. npm install Step 3: Add your API Key to the index.js file. Here, we will add our Secret API key from ApyHub. To generate an API key, you can visit the documentation page of AI Summarize Document API. Your secret looks like this ➡️
apy-token: APY****************************************** Copy this token and paste it in as shown in the code comment below. const express = require('express');
const fileUpload = require('express-fileupload');
const cors = require('cors');
const axios = require('axios');
const FormData = require('form-data');
const open = require('open');
const app = express();
const port = 3000;

app.use(cors());
app.use(fileUpload());

// Serve static files from the 'public' directory
app.use(express.static('public'));

app.post('/summarize', (req, res) => {
    console.log("summarixe called", req.files.file);
    if (!req.files || Object.keys(req.files).length === 0) {
        return res.status(400).send('No files were uploaded.');
    }

    // Assuming the file is attached to the request under the key 'file'
    const file = req.files.file;

    // Prepare the file to be sent using form-data
    const formData = new FormData();
    formData.append('file', file.data, file.name);

    // Set up the request headers, including the dynamic headers from form-data and the secret-apy token.
    const requestHeaders = {
        ...formData.getHeaders(),
        'apy-token': 'ADD YOUR OWN APY-TOKEN HERE'
    };

    // Call the AI Summarize API
    axios.post('https://api.apyhub.com/ai/summarize-documents/file', formData, { headers: requestHeaders })
        .then(apiResponse => {
            // Assuming the API returns JSON with a summary field
            console.log(apiResponse.data.data.summary);
            res.send({ summary: apiResponse.data.data.summary });
        })
        .catch(error => {
            console.error('Error calling the AI Summarize API:', error);
            res.status(500).send('Failed to summarize the document.');
        });
});

app.listen(port, () => {
    console.log(`Server running at http://localhost:${port}`);
    // Open the index.html file in the default browser
    open(`http://localhost:${port}`);
}); Once you’ve added the API key. Save the changes using the Ctrl+S Key. Step 4: Running Your Application Once you’ve added the API key. Save the changes using Ctrl+S in your terminal, and run this command.: node index.js That’s it :) As you can see, Now you can generate a meeting transcript anytime you want :) Virtual Meetings have become an essential part of corporate collaboration, serving as the de facto way that ideas are exchanged, decisions are made, and strategies are devised. However, the true value of meetings is often diluted by their length and the complexity of the discussions. This is why note-taking and effective summaries and action points are so important. Converting long and often pointless discussions into short (actionable) summaries, meeting attendees can quickly catch up on meetings they missed, review decisions that were made, and understand discussions without having to sift through hours and hours of recordings. We thought it would be cool to create our summarizer. If you don't have one already, keep reading. This technical tutorial will guide you through creating a simple web application that summarizes daily meeting Transcripts using ApyHub’s AI Summarize Document API using NodeJS. ApyHub’s AI Summarize Document API Pre-requisites: Access to Google Meet and permission to access meeting transcripts. A preferred programming language environment (e.g., Python). ApyHub Account. GitHub CLI is installed on your computer. Access to Google Meet and permission to access meeting transcripts. Google Meet A preferred programming language environment (e.g., Python). ApyHub Account . ApyHub Account GitHub CLI is installed on your computer. Step 1: Clone the GitHub repository Open your terminal and run this command: git clone https://github.com/iamspathan/AI-Transcript-Summarizer.git git clone https://github.com/iamspathan/AI-Transcript-Summarizer.git This command will clone the project in your local environment. Once the project is cloned, you can open the repository in the code editor. Step 2. Install Required Packages: Here, in Node Package Manager (npm), we will install all the dependencies that our application needs to summarize the meeting transcribe. npm install npm install Step 3: Add your API Key to the index.js file. Here, we will add our Secret API key from ApyHub. To generate an API key, you can visit the documentation page of AI Summarize Document API . Your secret looks like this ➡️ apy-token: APY****************************************** AI Summarize Document API apy-token: APY****************************************** Copy this token and paste it in as shown in the code comment below. const express = require('express');
const fileUpload = require('express-fileupload');
const cors = require('cors');
const axios = require('axios');
const FormData = require('form-data');
const open = require('open');
const app = express();
const port = 3000;

app.use(cors());
app.use(fileUpload());

// Serve static files from the 'public' directory
app.use(express.static('public'));

app.post('/summarize', (req, res) => {
    console.log("summarixe called", req.files.file);
    if (!req.files || Object.keys(req.files).length === 0) {
        return res.status(400).send('No files were uploaded.');
    }

    // Assuming the file is attached to the request under the key 'file'
    const file = req.files.file;

    // Prepare the file to be sent using form-data
    const formData = new FormData();
    formData.append('file', file.data, file.name);

    // Set up the request headers, including the dynamic headers from form-data and the secret-apy token.
    const requestHeaders = {
        ...formData.getHeaders(),
        'apy-token': 'ADD YOUR OWN APY-TOKEN HERE'
    };

    // Call the AI Summarize API
    axios.post('https://api.apyhub.com/ai/summarize-documents/file', formData, { headers: requestHeaders })
        .then(apiResponse => {
            // Assuming the API returns JSON with a summary field
            console.log(apiResponse.data.data.summary);
            res.send({ summary: apiResponse.data.data.summary });
        })
        .catch(error => {
            console.error('Error calling the AI Summarize API:', error);
            res.status(500).send('Failed to summarize the document.');
        });
});

app.listen(port, () => {
    console.log(`Server running at http://localhost:${port}`);
    // Open the index.html file in the default browser
    open(`http://localhost:${port}`);
}); const express = require('express');
const fileUpload = require('express-fileupload');
const cors = require('cors');
const axios = require('axios');
const FormData = require('form-data');
const open = require('open');
const app = express();
const port = 3000;

app.use(cors());
app.use(fileUpload());

// Serve static files from the 'public' directory
app.use(express.static('public'));

app.post('/summarize', (req, res) => {
    console.log("summarixe called", req.files.file);
    if (!req.files || Object.keys(req.files).length === 0) {
        return res.status(400).send('No files were uploaded.');
    }

    // Assuming the file is attached to the request under the key 'file'
    const file = req.files.file;

    // Prepare the file to be sent using form-data
    const formData = new FormData();
    formData.append('file', file.data, file.name);

    // Set up the request headers, including the dynamic headers from form-data and the secret-apy token.
    const requestHeaders = {
        ...formData.getHeaders(),
        'apy-token': 'ADD YOUR OWN APY-TOKEN HERE'
    };

    // Call the AI Summarize API
    axios.post('https://api.apyhub.com/ai/summarize-documents/file', formData, { headers: requestHeaders })
        .then(apiResponse => {
            // Assuming the API returns JSON with a summary field
            console.log(apiResponse.data.data.summary);
            res.send({ summary: apiResponse.data.data.summary });
        })
        .catch(error => {
            console.error('Error calling the AI Summarize API:', error);
            res.status(500).send('Failed to summarize the document.');
        });
});

app.listen(port, () => {
    console.log(`Server running at http://localhost:${port}`);
    // Open the index.html file in the default browser
    open(`http://localhost:${port}`);
}); Once you’ve added the API key. Save the changes using the Ctrl+S Key. Ctrl+S Step 4: Running Your Application Once you’ve added the API key. Save the changes using Ctrl+S in your terminal, and run this command.: node index.js node index.js That’s it :) As you can see, Now you can generate a meeting transcript anytime you want :)

Building an AI-Powered Summarizer using NodeJS and ApyHub API To Make Meetings Easy

Designed for developers at the intersection of curiosity and professional growth, this primer aims to illuminate how asynchronous programming can elevate application performance, scalability, and responsiveness. By focusing on the universal principles of non-blocking operations and event loops, we venture beyond specific technologies like AsyncIO, Node.js, or Go. This exploration is crafted for software developers eager to grasp the efficiencies driving modern software without the complexity of technical jargon. Think of how a single thread handling requests is like a single-lane road in a busy city: each request is a car, and when there's only one lane, cars line up, causing delays. But what if our city — our service — could manage traffic more cleverly? That's where the magic of an asynchronous runtime comes into play. It's like adding an intelligent traffic system to our city, guiding cars through multiple lanes and intersections without waiting. This system keeps traffic flowing smoothly, ensuring no car (or task) waits too long, which is precisely how an asynchronous runtime keeps our software running efficiently. Let's consider an example of a service that completes I/O operations synchronously. For clarity, these operations are shown outside the main flow of execution in the diagram: Blocking I/O during your service's startup phase might be acceptable, but avoiding this approach when processing external requests is advisable. The following diagram illustrates how service efficiency can be enhanced through the adoption of non-blocking I/O operations: These examples highlight scenarios where the server's performance gains are maximized. Nevertheless, the advantage of non-blocking operations persists across any frequency of incoming requests. Even in less-than-ideal conditions, performance benefits from integrating dedicated I/O threads into the processing workflow. The total time required to process a request (from the client's initial request to the final response, as depicted by the blue number on the right) will invariably decrease, provided there are sufficient threads to handle all requests. In the worst-case scenario, this duration will not surpass that of synchronous processing methods. We then encounter a practice that might seem counterintuitive to many developers. When I/O operations constitute a significant portion of request processing time, optimizing other code segments may yield slight improvement. The duration to fetch data from a cache might align closely with the time dedicated to business logic and template rendering. Employing caching or an in-process database can reduce data retrieval times compared to other processing activities. To segment code effectively and facilitate callback execution, one can instruct the runtime to proceed to the next event loop cycle. Below is an illustrative example of how this concept is applied: // blocking callbacks
function func1_cb(str, cb) {
 var res = func1(str);
 cb(res);
}

function func2_cb(str, cb) {
 var res = func2(str);
 cb(res);
}

// non-blocking callbacks
function func1_cb(str, cb) {
 var res = func1(str);
 process.nextTick(function () {
   cb(res);
 });
}

function func2_cb(str, cb) {
 var res = func2(str);
 process.nextTick(function () {
   cb(res);
 });
}

// usage example
func1_cb(content, function (str) {
 func2_cb(str, function (result) {
   // work with result
 });
}); By adopting this methodology to split two parts of calculations, the overall processing time for scenarios with nearly concurrent request arrivals remains the same. However, the response to the first request is delayed: This scenario represents the least favorable outcome when employing the “next tick” strategy. As shown in the initial example, the “next tick” method proves benign for infrequent requests. Should requests arrive at a moderate pace, leveraging this technique enhances processing speed by allowing the initiation of new requests and the start of non-blocking operations to be interleaved during execution breaks. This approach effectively reduces both the total processing time and the average time per request: In conclusion, adopting non-blocking I/O is crucial for enhancing application performance and beneficial in environments with both sparse and heavy incoming request volumes. Additionally, effectively sequencing the execution flow — illustrated by concepts similar to the "next tick" technique — significantly improves server efficiency. Embracing these asynchronous programming practices offers clear advantages over traditional, synchronous methods.

Asynchronous Runtimes: A Primer for the Perplexed Developer

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

Introduction The article highlights the importance of limiting the concurrent asynchronous operations, which in turn improves performance. Learning Objectives The common mistake all developers do How to use limit concurrent async operations Best Practices Prerequisites for Developers Basic understanding of C# programming language Basic understanding of asynchronous programming using async await Getting Started The common mistake all developers do Consider an example where the user wants to load data asynchronously within a method, and it highlights the common mistake developers make. (async item => await ProcessItem(item));
/// <summary>
/// Old approach with classic async await 
/// </summary>
/// <returns></returns>
public async static Task OldApproach(List<string> items)
{
    var tasks = items.Select(async item => await ProcessItem(item));
    await Task.WhenAll(tasks);
} The approach may look clean and simple, but it initiates tasks for each item in the collection concurrently. This can cause system strain under heavy List<string> items, which will produce poor application performance. Optimized approach with Concurrency Limit Let’s transform the above method using SemaphoreSlim to limit the number of concurrent asynchronous operations. The following code snippet demonstrates the more refined approach. /// <summary>
/// Optimized approach with limit concurrency
/// </summary>
/// <returns></returns>
public static async Task OptimizedApproachAsync(List<string> items, int maxConcurrency = 10)
{
    using (var semaphore = new SemaphoreSlim(maxConcurrency))
    {
        var tasks = items.Select(async item =>
        {
            await semaphore.WaitAsync(); // Limit concurrency by waiting for the semaphore.
            try
            {
                await ProcessItem(item);
            }
            finally
            {
                semaphore.Release(); // Release the semaphore to allow other operations.
            }
        });

        await Task.WhenAll(tasks);
    }
} The aforementioned code prevents the system from being choked by too many concurrent tasks. Best Practices Please find below the best practices Limit Concurrency To balance system load and resources, it is recommended to use SemaphoreSlim Avoid Blocking Calls Avoid using  .Result or .Wait(), as they can lead to deadlocks and degrade performance. Async all the way Avoid mixing async and sync code. Ensure all methods are async from top to bottom to prevent deadlock and make optimal use of resources. Conclusion Asynchronous programming in C# involves more than just understanding the async and await keywords; it requires more features like concurrency, resource utilization, and code structure Complete Code on GitHub GitHub — ssukhpinder/30DayChallenge.Net C# Programming🚀 Thank you for being a part of the C# community! Before you leave: If you’ve made it this far, please show your appreciation with a clap and follow the author! 👏️️ Follow us: | | | | | X LinkedIn Dev.to Hashnode Newsletter Tumblr Visit our other platforms: | | | | GitHub Instagram Tiktok Quora Daily.dev More content at C# Programming Also published . here

The 30-Day .NET Challenge Day 14: Limit Concurrent Async Operations

This paper is available on arxiv under CC 4.0 license. Authors: (1) Vianney Brouard, ENS de Lyon, UMPA, CNRS UMR 5669, 46 All´ee d’Italie, 69364 Lyon Cedex 07, France; E-mail: vianney.brouard@ens-lyon.f. Table of Links Abstract & Introduction and presentation of the model Main results and biological interpretation First-order asymptotics of the mutant sub-populations for an infinite mono-directional grap First-order asymptotics of the mutant sub-populations for a general finite trait space (Theorem 2.1) Convergence for the stochastic exponents (Theorem 2.2) Acknowledgements & References 3 First-order asymptotics of the mutant sub-populations for an infinite mono-directional grap In this section consider the model described in Section 1 in the particular following infinite monodirectional grap Assume in the case of the infinite mono-directional graph that A graphical representation of the model can be found in Figure 5. In particular it means that any Compared to the general finite graph, for any trait i ∈ N there is only one path from trait 0 to i for this mono-directional graph. In particular it implies that Notice in particular that with such a construction it immediately follows the monotone coupling Denote by see [12] Section 1.1, or [11] Theorem 1. 3.1 The wild-type dynamics Using Ito’s formula and (18) it follows Solving this equation we obtain for all t ≥ 0 Similarly we have Consequently combining (21), (22) and (23) gives that Finally we have which concludes the proof. Proof of Lemma 3.2. Let ε > 0 and for all n ∈ N introduce the event We start by showing that for all 0 < δ1 < δ2 Step 1: from which we obtain Remark 3.1. From Lemma 3.2, it follows the useful result 3.2 The mutant sub-populations dynamics in the deterministic time-scale (Theorem 2.1 (i)) In this subsection, Equations (11) and (12) are proven for the mono-directional graph. It will be done in two steps. The first one will consist in showing the result for a fixed s ∈ R and uniformly in the parameter t. Then in the second step, the result will be proved uniformly in the parameter 3.2.1 Uniform control on the time parameter In this subsection we are going to prove the following proposition, which is a less refine result of (11) and (12), because the result is not uniform on the parameter s. The proof is done by induction on i ∈ N. As long as the proof is similar for the initialization and the inductive part the step considered will not be specified. To make the proof the clearer possible it is cut using several lemmas. All the results are obtained using a martingale approach. In the next Lemma the martingales that are considered for all the mutant sub-populations are introduced, and their quadratic variations are computed. Lemma 3.3. For all i ∈ N define Proof of Proposition 3.1. Let i ∈ N ∗ . For i ≥ 2 assume that Proposition 3.1 is true for i − 1. We start by showing the result when i is a neutral trait, that is to say we are going to prove (27). All the lemmas that we are mentioning in the proof are free from such neutral assumption, and work also for deleterious mutant traits. We are going to show that (33), (34) and (35) converges to 0 when n goes to infinity. (33): Step 1: Convergence to 0 of = 1: (i) Case i Using Equation (38) we have that (40) For i = 1 we prove without condition. It allows to write (44) For i = 1 we prove without condition. Let Proof of Lemma 3.6. Using similar computations as in (46) and (47), it follows (45). First, a natural upper bound on the mean of the growth of each mutant sub-population can be easily obtained. This is stated in the next Lemma. Second, using both the expression of the quadratic variation of the martingale associated to a mutant sub-population given in Equation (30) and the previous Lemma 3.7, a natural upperbound on its mean is obtained and summed up in the next Lemma. First notice that the function is a non-decreasing function implying that Notice that Then for n large enough, and remembering that θ(i) = θ(i − 1) + 1 we have And we have Then for large enough, and remembering that 1) we have n θ(i) = θ(i − Then by hypothesis on (ψn(i), γn(i)) it follows that (41) converges to 0. (35): Step 3: Convergence to 0 of Notice that for all t ≥ t(i) Then it allows to write Then combining (52) and (53) we get as θ(i) ≥ 1 since the vertex i is assumed to be neutral. It ends the proof of the convergence to 0 of the term (49). The term (50) converges to 0 according to the following Lemma. Lemma 3.9. Assume Equation (15). Let i ∈ N, T ≥ t(i) and s ∈ R. For i ≥ 2 we prove that if Proposition 3.1 is true for i − 1 then (54) For i = 1, we prove without condition. Our aim is to prove that for all ε > 0 = 1: We have (i) Case i Let us set 3.2.2 Uniform control on the parameter s In this subsection we will prove (11) and (12) from (27) and (28) using an idea from the proof of Lemma 3 of [15]. We start by showing (12). We will use that It gives that Hence we get for sufficiently large n from which (12) is obtained. Indeed the term (63) converges to 0 according to Equation (28) and (64) converges to 0 since W is finite almost surely (see (20)). We now show Equation (11). We have Finally using (65) and (66) we obtain for all (t, s) ∈ [0, T] × [−M, M] Then it follows that where the different convergences to 0 are obtained in the following way: 3.3 First-order asymptotics of the mutant sub-populations in the random time-scale (Theorem 2.1 (ii))

First-order Asymptotics of the Mutant Sub-populations for an Infinite Mono-directional Grap

This paper is available on arxiv under CC 4.0 license. Authors: (1) Vianney Brouard, ENS de Lyon, UMPA, CNRS UMR 5669, 46 All´ee d’Italie, 69364 Lyon Cedex 07, France; E-mail: vianney.brouard@ens-lyon.f. Table of Links Abstract & Introduction and presentation of the model Main results and biological interpretation First-order asymptotics of the mutant sub-populations for an infinite mono-directional grap First-order asymptotics of the mutant sub-populations for a general finite trait space (Theorem 2.1) Convergence for the stochastic exponents (Theorem 2.2) Acknowledgements & References 4 First-order asymptotics of the mutant sub-populations for a general finite trait space (Theorem 2.1) Notice that with such a construction it immediately follows the monotone coupling In the next definition, we are going to introduce an equivalence relation on Γ(V ). Two paths are said to be equivalent if they are the same up to cycles (in particular cycles formed by backward mutations are taken into account). More precisely, that there exists a minimal path, from which the two previous paths are using all the edges, but potentially also some other edges forming cycles. The aim of this equivalence relation is to say that among one class of equivalence, only the path with the minimal length may contribute for the asymptotic of the mutant sub-population sizes Now we have all the preliminary results and definitions to prove Theorem 2.1. We show Equation (11). The proof of Equation (12) is similar and is left to the reader. Proof of Theorem 2.1. And the last term of the r.h.s converges to 0 because

First-order Asymptotics of the Mutant Sub-populations for a General Finite Trait Space (Theorem 2.1)

Events and event handlers aren’t necessarily the most common language feature being used if you’re focused on web development in ASP.NET Core… but if you’re building applications in WinForms, WPF, Maui — or anything with a user interface really — it’s almost guaranteed you’ll be using these. Given how pervasive async await code is now, that also suggests you’re probably going to run into async event handlers in C# at some point too. Async event handlers have their challenges. They’re essentially two things that conceptually fit nicely together, but the language features of C# break down for us right where these two things intersect. In this article, I’ll explain why there are risks, what those risks are, and what you can try and do to make things better. Understanding Async Event Handlers in C# Async event handlers in C# allow you to handle asynchronous events that occur during the execution of a program. These events can include user input, network requests, or any other asynchronous operations. These methods are marked with the keyword, indicating that they contain asynchronous operations, and therefore we can await other calls within them. When an event is triggered, the async event handler is invoked and runs concurrently with the rest of the program. async A traditional synchronous event handler in C# has the following syntax: void MyEventHandler(object sender, EventArgs e)
{
    // TODO: handle the event
} But if we need one to run asynchronously, it will look like this: async void MyEventHandler(object sender, EventArgs e)
{
    // TODO: handle the event, running the asynchronous code we can await on
} Keeping in mind that event handlers in C# *must* have a void return type, what kind of problem do we have here? What Makes Async Event Handlers in C# Dangerous? While async event handlers offer great flexibility and improved responsiveness, they also introduce a set of potential dangers and risks that you need to be aware of. And I don’t blame you if either you weren’t aware of these or you were aware but weren’t sure the best way to navigate these issues… because it’s a very awkward intersection of event handler syntax and async-await code. Fundamentally, issues arise because of the declaration of the event handler. When we start using async await, we’re told early on that using async void is a big no-no. async void And why is that? It eliminates the possibility for us to await the asynchronous operation — that’s what Task allows us to do. When we’re unable to leverage a task to await, we lose the ability to manage the execution of the task, including exception handling. That means if your event handler goes boom, then your app is going to go boom somewhere else. And you won’t be able to gracefully deal with it. Key Risks With Async Event Handlers in C# Now that you understand what makes them dangerous in general, here are a few key risks associated with async event handlers in C#: Unobserved exceptions: When an async event handler encounters an exception during its execution, it can cause an unhandled exception if the error is not properly handled. This can lead to unexpected program behavior or even crashes. It’s important to handle exceptions appropriately to prevent these issues. This was the focus of the previous section. Concurrency concerns: Async event handlers run concurrently with the rest of the program, making it important to consider potential concurrency issues. Concurrent access to shared resources can lead to race conditions, data corruption, or inconsistent state. When we’re doing async await, sure, we are dealing with concurrency… But now we just have an async body of code running off potentially into outer space that we can’t align with. And of course, the async flavor of event handlers in C# carries the same potential memory-leak issue. We’ll skip the details here but just remember to unhook events when you’re done requiring the registration and properly manage your event and event handler lifetimes! Handling Async Event Handlers Safely in C# Async event handlers in C# can introduce some potential issues if not handled properly. I’ve tried coming up with alternative solutions in the past to async void code as well as helpers that could clean up the syntax when trying to write safe event handlers. Ultimately, these are either incredibly complex or in the simple case the syntax just feels a bit off. This section will detail some general simple strategies you can employ to make these less of a headache — but the responsibility is still on you to add them! Wrap Async Event Handlers with Try/Catch If we accept that we’re stuck using for event handlers, the biggest concern for us to address is catching exceptions. Once an exception bubbles up and hits that async void boundary, it’s game over. There’s not going to be an elegant way for your application to handle that. The current call stack will be unable to properly catch this even if you wrapped the event invocation in a try/catch. [async void](https://www.devleader.ca/2023/01/27/async-void-how-to-tame-the-asynchronous-nightmare/) To mitigate this risk, use a block at the top level of your event handler. Make it the first and last thing that your event handler does so there’s no way for code to throw exceptions without being wrapped with a catch block: try-catch async Task MyEventHandler(object sender, EventArgs e)
{
    try
    {
        // TODO: do the async code
    }
    catch (Exception)
    {
        // Handle cancellation
    }
} This still sucks because it’s manual, but maybe someone could make a Roslyn analyzer to enforce this?! Also, notice that I’m catching *all* exceptions here… But what are we expecting to do about it? Truly, unless we’re ready for our application to crash or experience weird behavior, we need to stop exceptions from bubbling out of an async void method. Maybe logging or telemetry? But not a lot of great options by default. Force Timeout on Async Event Handlers Here’s a not-so-silver-bullet option you could add to the mix for working with async event handlers. Sometimes, async operations within an event handler can take longer to complete than expected. Recall that we can’t easily manage this async void call because we can’t await it and we don’t have a task object to work with. But if we could do *something* to help keep these from running away with resources in some sort of infinite loop, we could introduce a cancellation token timed with some maximum allowable time. See the example below which includes the suggestion from the previous section: async void MyEventHandler(object sender, EventArgs e)
{
    using (var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5)))
    {
        try
        {
            // Continue with async operation, pass in cancel token
        }
        catch (OperationCanceledException)
        {
            // Handle cancellation
        }
        catch (Exception ex)
        {
            // TODO: how should we handle these?
        }
    }
} In the code above, we simply try to limit execution to no longer than 5 seconds. As long as the async code we implement within here takes advantage of the cancellation token, then they should be able to handle canceling properly. But that does mean that *someone* still needs to carry that responsibility. Wrapping Up Async Event Handlers in C# In summary, understanding and safely managing async event handlers in C# is important for C# developers. Async event handlers have their own set of dangers and complexities that need to be addressed to ensure the stability and efficiency of software applications. These can be challenging to be aware of in the first place, but even once you’re aware… what’s the best way to solve them? Hopefully from this article you understand why these are challenging and some strategies to help. If you found this useful and you’re looking for more learning opportunities, consider and check out my ! subscribing to my free weekly software engineering newsletter free videos on YouTube Also published here.

What You Need to Know About Async Event Handlers in C#

In Swift, using for asynchronous code may seem like pure hell because, under the hood, are considered complete if the compilation of their synchronous code is completed. OperationQueue Operations In other words, compiling the example described below will output a broken execution order since, by the time the asynchronous code is executed, the itself will have already been completed. Operation let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 1

operationQueue.addOperation {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
        print("First async operation complete")
    }
    print("First sync operation complete")
}

operationQueue.addOperation {
    DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) {
        print("Second async operation complete")
    }
    print("Second sync operation complete")
} This code will print: First sync operation complete
Second sync operation complete
First async operation complete
Second async operation complete However, there is a way to circumvent these restrictions. To understand how to solve the problem, you need to understand how works under the hood. Operation The itself has four flags by which you can track the life cycle of the operation: Operation — indicates whether the can be performed at this time. isReady Operation —indicates whether an is currently in progress. isExecuting Operation —indicates whether the is currently completed. isFinished Operation —indicates whether the was canceled. isCancelled Operation In theory, the enters the state before the itself is executed asynchronously, so we need to develop a technique by which we will be able to manipulate the life cycle of the . Operation isFinished Operation Operation This possibility can be solved by subclassing the and also by redefining the / methods, as well as all the flags on which the operation's life cycle is built. Operation start cancel Here’s the code: public class AsyncOperation: Operation {
    // MARK: Open

    override open var isAsynchronous: Bool {
        true
    }

    override open var isReady: Bool {
        super.isReady && self.state == .ready
    }

    override open var isExecuting: Bool {
        self.state == .executing
    }

    override open var isFinished: Bool {
        self.state == .finished
    }

    override open func start() {
        if isCancelled {
            state = .finished
            return
        }
        main()
        state = .executing
    }

    override open func cancel() {
        super.cancel()
        state = .finished
    }

    // MARK: Public

    public enum State: String {
        case ready
        case executing
        case finished

        // MARK: Fileprivate

        fileprivate var keyPath: String {
            "is" + rawValue.capitalized
        }
    }

    public var state = State.ready {
        willSet {
            willChangeValue(forKey: newValue.keyPath)
            willChangeValue(forKey: state.keyPath)
        }
        didSet {
            didChangeValue(forKey: oldValue.keyPath)
            didChangeValue(forKey: state.keyPath)
        }
    }
} The subclass we received from the is basic and allows us to forcefully complete it manually. Operation To work with completion blocks, you should create another subclass. However, this will not be a subclass of the , but of . Operation AsyncOperation public typealias VoidClosure = () -> Void
public typealias Closure<T> = (T) -> Void

public class CompletionOperation: AsyncOperation {
    // MARK: Lifecycle

    public init(completeBlock: Closure<VoidClosure?>?) {
        self.completeBlock = completeBlock
    }

    // MARK: Public

    override public func main() {
        DispatchQueue.main.async { [weak self] in
            self?.completeBlock? {
                DispatchQueue.main.async {
                    self?.state = .finished
                }
            }
        }
    }

    // MARK: Private

    private let completeBlock: Closure<VoidClosure?>?
} This subclass will allow us to pass a closure to the , after which the will be completed. Operation Operation Let’s try this type of operation in practice: let operationQueue = OperationQueue()
operationQueue.maxConcurrentOperationCount = 1

operationQueue.addOperation(
    CompletionOperation { completion in
        DispatchQueue.main.asyncAfter(deadline: .now() + 1) {
            print("First async operation complete")
            completion?()
        }
        print("First sync operation complete")
    }
)

operationQueue.addOperation(
    CompletionOperation { completion in
        DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) {
            print("Second async operation complete")
            completion?()
        }
        print("Second sync operation complete")
    }
) As a result, we were able to achieve synchronous execution of : Operations First sync operation complete
First async operation complete
Second sync operation complete
Second async operation complete Don’t hesitate to contact me on if you have any questions. Also, you can always . Twitter buy me a coffee Also published here

OperationQueue + Asynchronous Code: Everything You Need to Know

OperationQueue + অ্যাসিঙ্ক্রোনাস কোড: আপনার যা কিছু জানা দরকার

OperationQueue + Asynchroner Code: Alles, was Sie wissen müssen

OperationQueue + Código asincrónico: todo lo que necesita saber

OperationQueue + Code asynchrone : tout ce que vous devez savoir

ऑपरेशनक्यू + एसिंक्रोनस कोड: वह सब कुछ जो आपको जानना आवश्यक है

OperationQueue + 非同期コード: 知っておくべきことすべて

OperationQueue + 비동기 코드: 알아야 할 모든 것

OperationQueue + código assíncrono: tudo o que você precisa saber

OperationQueue + асинхронный код: все, что вам нужно знать

OperationQueue + Asenkron Kod: Bilmeniz Gereken Her Şey

OperationQueue + Mã không đồng bộ: Mọi thứ bạn cần biết

OperationQueue + 异步代码：您需要了解的一切

methods in are a source of a lot of problems for many developers getting into . The pattern that we’re suggested to use is of course , but there are cases — like with Event Handlers in C# — where the method signatures just aren’t compatible. async void C# writing async await code async Task In this article, I’ll explain why methods in C# are something you want to avoid. We’ll cover some code examples that compare and for better understanding, and I’ll also explain what you should do if you have no other choice but . async void async void async Task async void What Are async void Methods in C#? In C#, methods are a way to define asynchronous methods that don’t return a value. These methods are typically used for event handlers or other scenarios where the method signature being enforced does not support a return type and instead is enforced. async void Task void methods are defined by using the keyword before the method signature, followed by the return type . For example: async void async void public async void SomeMethod()
{
    // Code here
} When compared to regular asynchronous methods that return a or , there are a few important differences to note. And when I say “important” I mean “You really need to avoid this as much as you humanly can so you save yourself some headaches”. Task Task<T> Differences Between async void And async Task in CSharp One of the main differences between methods and methods lies in how exceptions are handled. [async void](https://www.devleader.ca/2023/01/27/async-void-how-to-tame-the-asynchronous-nightmare/) async Task In methods, any exceptions that occur are captured by the returned object. This allows the calling code to handle the exception or await the to observe any exceptions later. This is how the entire infrastructure has been built in C#. It’s often why you’ll see async await get introduced into a codebase and then all of the calling code starts getting converted over to also be async await — You really DO want it there. async Task Task Task async await On the other hand, methods cannot be awaited directly, and any exceptions that occur within them will be bubbled up to… where? The SynchronizationContext that started the async method in the first place. Even Stephen Cleary from Microsoft mentions in his article: async void With async void methods, there is no Task object, so any exceptions thrown out of an async void method will be raised directly on the SynchronizationContext that was active when the async void method started. illustrates that exceptions thrown from async void methods can’t be caught naturally. Figure 2 Stephen Cleary Code Example of async Task vs async void Methods in C# It’ll be helpful to compare two variations of the same layout of code using each of these patterns to see how the issues can arise. Consider the following example that uses async Task: public async Task ProcessDataAsync()
{
    // Some asynchronous operations
}

public async void HandleButtonClick(object sender, EventArgs e)
{
    try
    {
        await ProcessDataAsync();
    }
    catch (Exception ex)
    {
        // Handle the exception
    }
} In this code, if an exception occurs in the event handler method, it will be caught by the try-catch block in the method and can be appropriately handled. ProcessDataAsync HandleButtonClick However, if is defined as instead, any exceptions thrown by would bypass the catch block in the event handler method and potentially crash the application: ProcessDataAsync `async void` ProcessDataAsync HandleButtonClick public async void ProcessDataAsync()
{
    // Some asynchronous operations
}

public async void HandleButtonClick(object sender, EventArgs e)
{
    try
    {
        ProcessDataAsync();
    }
    catch (Exception ex)
    {
        // This will never catch the async exceptions!
    }
} The Dangers of async void Methods in C# The common theme that you’re hopefully noticing in this article is that methods in C# are dangerous and something you should be trying to avoid. Here’s a list of challenges that we get with methods, to hopefully steer you away from using them (unless you have no choice): async void [async void](https://www.devleader.ca/2023/01/27/async-void-how-to-tame-the-asynchronous-nightmare/) : methods do not allow errors to be caught or propagated. When an exception occurs within such a method, it escapes to the synchronization context, often resulting in an unhandled exception that can crash the application. Error Propagation async void : Unlike methods, methods cannot be awaited. This can lead to issues with controlling the flow of asynchronous operations, potentially causing race conditions or executing operations out of the intended order. Awaiting Behavior async Task async void : Debugging exceptions in methods is more challenging because the call stack may not accurately represent the execution flow at the time the exception was thrown, complicating the process of identifying and fixing bugs. Debugging Difficulty async void Best Practices for Handling async void Methods in C# When working with async void methods in C#, it is important to be aware of their potential dangers and follow best practices to ensure a robust and reliable codebase. Here are some recommendations for handling async void methods cautiously: Avoid whenever possible: methods should generally be avoided, especially in scenarios where exception handling and error recovery are critical. While async void methods may appear convenient, they cannot propagate exceptions and can result in unpredictable program behavior. Instead, consider using methods, which provide better error-handling capabilities. async void async void async Task Use instead: By using the return type for asynchronous methods, you can take advantage of the Task’s built-in exception handling mechanism. This enables you to catch and handle exceptions appropriately, ensuring that your code maintains control over the execution flow. Using methods also allows for better code maintainability, testability, and fewer mysterious problems than . async Task async Task async Task async void Handle exceptions in methods: If you must use methods, it is important to properly handle exceptions to prevent them from silently propagating and causing unexpected system behavior. One way to achieve this is by enclosing the code within a try/catch block. Within the catch block, you can log the exception and handle it accordingly, such as displaying an error message to the user or rolling back any relevant operations. async void async void Log and monitor asynchronous operations: When working with methods, logging and monitoring become even more critical. Since these methods do not have a return type, it becomes challenging to determine their completion or identify any potential issues. Implementing a robust logging and monitoring system, such as using a logging framework like Serilog or utilizing application insights, can help track the progress and status of your asynchronous operations, aiding in debugging and troubleshooting. async void Try/Catch for async void Methods in C# , but ultimately it feels like making sure you wrap every method body in try/catch is the most straightforward. Maybe someone can create a Rosyln analyzer to enforce this? I’ve written about several different ways to try working with this kind of code before async void Here’s an example demonstrating how you can use a try-catch around the entire body of code that is : async void public async void DoSomethingAsync()
{
    try
    {
        // Perform asynchronous operations
        await Task.Delay(1000);
        await SomeAsyncMethod();
    }
    catch (Exception ex)
    {
        // TODO: ... whatever you need to do to properly report
        // on issues in your async void calls so that you
        // can debug them more effectively.

        // Log the exception and handle it appropriately
        Logger.Error(ex, "An error occurred while executing DoSomethingAsync");
        // Display an error message or take necessary action
        DisplayErrorMessage("Oops! Something went wrong. Please try again later.");
    }
} By adhering to these best practices, you can mitigate the risks associated with methods and avoid a pile of neverending headaches. Remember to prioritize using methods whenever possible for better exception handling and control over the asynchronous execution flow — you don’t want to add anywhere unless it’s an absolute last resort. async void async Task really async void Wrapping up async void Methods in C# In conclusion, methods in C# can be dangerous for several reasons, and you’ll want to prioritize NOT using them. There are unfortunate situations where APIs and method signatures do not line up, such as Event Handlers, but otherwise, do your best to avoid these. async void By using , we lose the ability to await or handle exceptions properly. This can lead to unhandled exceptions and unexpected behavior in our code. To avoid these hazards, I recommend that you use for methods that are intended to be asynchronous wherever you possibly can. This allows us to await the result, handle exceptions, and have better control over our code’s execution flow. It promotes better error handling and improves overall code quality. When you have no other choice, make sure you are wrapping your entire async void method in a try/catch and investing in proper error handling/logging/reporting. async void async Task Approach async programming with caution and continuously seek to enhance your understanding of the topic! If you found this useful and you’re looking for more learning opportunities, consider and check out my ! if you want to connect with me and other software engineers on these types of topics! subscribing to my free weekly software engineering newsletter free videos on YouTube Check out my Discord community Also published . here

The Dangers of Using async void Methods In C#

Async await in is a feature that allows you to write asynchronous code that is easy to read and maintain. It greatly simplifies how you handle asynchronous operations by providing a structured way to await tasks and their results. With the rate at which computers are scaling performance & cores, and our growing need to interface with many external services, async await in C# can make our developer lives easier. C# In the following sections, I’ll highlight 3 beginner tips for using async await in C#. Each tip will be accompanied by a code example, allowing you to see these concepts in action. These cancellation, and performance optimization, so you’ll be off to the races writing async code. tips will cover important aspects such as error handling, Tip 1: Understand the Basics of async await in C# Async await in C# are two special keywords that are used to handle asynchronous code execution. Asynchronous programming enables us to write C# code that can perform multiple operations concurrently, improving the overall performance and responsiveness of an application. In C#, a task represents an asynchronous operation and it’s used to encapsulate a unit of work that can be executed concurrently with other tasks. When using async/await, you can use tasks to handle and manage asynchronous operations in a structured way. To define an async method in C#, you need to add the async modifier to the method signature. For example: public async Task DoAsyncWork()
{
    // Asynchronous code here
} In the above example, the method is declared as async and returns a . This indicates that the method will perform asynchronous operations and can be awaited. DoAsyncWork Task Within the async method, you can use the await keyword to signal the point where the execution should wait for the completion of an asynchronous operation. For example: public async Task DoAsyncWork()
{
    // Perform asynchronous operations
    await Task.Delay(1000);

    // Continue with other operations
} In the above example, the statement pauses the execution of the method until the operation completes. This allows other code, such as other async tasks, to execute concurrently. By using tasks, you can of asynchronous programming in C#. await Task.Delay(1000) Task.Delay harness the power Tip 2: Handling Multiple Exceptions with async await . When working with async code in C#, handling exceptions can present some challenges due to the asynchronous nature of the code. In certain situations, multiple exceptions can occur when executing async code. It’s important to be able to handle and aggregate these exceptions effectively. To handle multiple exceptions, C# provides the class, which allows us to group and manage multiple exceptions as a single entity. Exception handling is an important aspect of writing any software application AggregateException When multiple exceptions occur in an async operation, the class collects these exceptions and allows us to access and handle them in a centralized manner. This can be particularly useful for scenarios where we need to process all exceptions generated during an async operation. To handle exceptions using the class, we can wrap the code that may throw exceptions in a try-catch block. Within the catch block, we can access the property of the to access each individual exception that occurred. AggregateException AggregateException InnerExceptions AggregateException Here’s an example of how to use the class to handle and aggregate exceptions in async code: AggregateException try
{
    await SomeAsyncOperation();
}
catch (AggregateException ex)
{
    foreach (var innerException in ex.InnerExceptions)
    {
        // Handle each individual exception
        Console.WriteLine($"Exception: {innerException.Message");
    }
} In the example above, represents an async operation that may throw one or more exceptions. By wrapping the statement in a try-catch block and catching an , we are able to access and handle each individual exception that occurred within the async operation. By properly handling and aggregating exceptions in async code using the class, we can ensure that our code can gracefully handle any unexpected errors that may occur during async operations. SomeAsyncOperation await AggregateException AggregateException Tip 3: Avoiding Deadlocks with async await Deadlocks can occur when two or more tasks are waiting for each other to complete indefinitely, resulting in a state where none of the tasks can proceed. Stop Blocking Your Async Calls! One of the most common causes of deadlocks in async methods includes using the or methods inside an async method, which blocks the main thread and can lead to deadlocks. The best advice for avoiding deadlocks with async code: Task.Result Task.Wait “Don’t block on async code” Stephen Cleary He points out in his article that this tip (stop blocking) or the tip that immediately follows this (configuring the awaiter) are both able to help prevent deadlocks… but relying ONLY on the next pattern is more of a risk. That is, of these two suggestions, making your C# code async await all of the way through is the safer bet. That means instead of having something like: public class MyController(
  IWeatherService _weatherService) :
  ApiController
{
  public string GetWeatherData()
  {
    var weatherData = _weatherService.GetWeatherData(...).Result;
    return Results.OK(weatherData);
  }
} Instead, we’d make the top-level async as well: public class MyController(
  IWeatherService _weatherService) :
  ApiController
{
  public async Task<string> GetWeatherData()
  {
    var weatherData = await _weatherService.GetWeatherData(...);
    return Results.OK(weatherData);
  }
} As soon as we introduce a or call, we are effectively blocking — and that is one of the key situations that can lead to deadlocks as the application gets more complex. .Result .Wait() Using ConfigureAwait(false) with Async Await in C# To prevent deadlocks, the method can be used with the parameter. This instructs the operator to not capture the current synchronization context, allowing the continuation to be executed on any available thread from the thread pool — not just the thread that started the call! ConfigureAwait false await With , we can explicitly state that we do not require the original synchronization context to be captured, preventing the deadlock issue. Keep in mind that using should be done carefully and only when it is absolutely necessary, as it may introduce potential issues if the code relies on the captured synchronization context for specific requirements. For example, if you’re running UI logic and you come back to execution not on the UI thread, you may be in for some surprises! ConfigureAwait(false) ConfigureAwait(false) Let’s take a look at an example to illustrate the usage of to prevent deadlocks: ConfigureAwait(false) public async Task<string> GetDataAsync()
{
    // NOTE: assume we enter this method on some given thread

    // use a false parameter on ConfigureAwait
    await SomeAsyncMethod().ConfigureAwait(false);

    // NOTE: we could be on a different thread than when we started this method!

    return ProcessData();
} In the above example, is awaited using . This allows the continuation of the code to execute on any available thread, ensuring that the synchronization context is not captured and preventing potential deadlocks. SomeAsyncMethod ConfigureAwait(false) And while Stephen Cleary does say that this will help prevent deadlocks, he also had this to add: Using to avoid deadlocks is a dangerous practice. You would have to use for in the transitive closure of all methods called by the blocking code, . Using to avoid deadlock is at best ). ConfigureAwait(false) ConfigureAwait(false) every await including all third- and second-party code ConfigureAwait(false) just a hack Stephen Cleary Wrapping up Async Await in C# In this article, I’ve discussed 3 beginner tips for using async await in C# to write concurrent code. Async await in C# can be a lot to absorb right in the beginning, so it will take some time and practice for it to feel more natural! We got to see the basics of the keyword usage for async await — With this, you can now write asynchronous code! From there, we looked at how multiple exceptions can arise in async await code paths and how to navigate that. And we concluded with some ideas around preventing deadlocks by looking at 2 possibilities we can leverage. Async await in C# is something you’re going to want to learn and practice! If you found this useful and you’re looking for more learning opportunities, consider and check out my ! subscribing to my free weekly software engineering newsletter free videos on YouTube Also published here.

3 Beginner Tips You Need to Know for async await in C#

Asynchronous programming has become a cornerstone of modern . In the iOS ecosystem, introduced native support for asynchronous programming with Swift, including the powerful async/await pattern. In this article, we'll delve into the usage of async/await in iOS development app development Apple Understanding async/await Async/await is a programming paradigm that streamlines the execution of asynchronous code, making it appear more synchronous and readable. It eliminates the complexities of managing callbacks or completion handlers, allowing developers to write asynchronous code that same as synchronous code. With Swift's async/await, developers can efficiently handle tasks such as network requests, database queries, or file I/O without blocking the main thread Basic Usage of async/await in iOS: To create an asynchronous function, simply use the keyword in the function declaration. This signifies that the function will execute asynchronous tasks. Define an async Function: async func fetchData() async -> Data {
    // async operations
} Within an async function, utilize the keyword to call other asynchronous functions or tasks. It suspends the current task until the awaited task is completed. Use await Inside an async Function: await func fetchImageData() async -> Data {
    let url = URL(string: "https://example.com/image.jpg")!
    do {
        let (data, _) = try await URLSession.shared.data(from: url)
        return data
    } catch {
        // Handle errors
    }
} When calling an async function from another function, mark the calling function as async as well. This facilitates the use of for calling async functions. Mark the Caller as async: await func displayImage() async {
    let imageData = await fetchImageData()
    let image = UIImage(data: imageData)
    // Update UI with the image
} Error handling with async/await is straightforward. Utilize and blocks to handle errors thrown within async functions. Error Handling: try catch func fetchImageDataWithThrowing(stringURL: URL) async throws -> Data {
    guard let url = URL(string: stringURL)
    else { throw NSError(domain: "Bad URL", code: 0) }
    
    let (data, _) = try await URLSession.shared.data(from: url)
    return data
}

func displayData() async {
    let url = "https://example.com/image.jpg"
    do {
        let data = try await fetchImageDataWithThrowing(stringURL: url)
        // Process data
    } catch {
        // Handle errors
    }
} To update the UI on the main thread within async code, use to dispatch code to the main queue. Running async Code on the Main Thread: await Task {
    await MainActor.run {
        // Update UI
    }
} or Task { @MainActor in
    // Update UI
} Advanced Use Cases: Utilize the structure to denote the scope of an asynchronous call within synchronous code. Calling an Asynchronous Function in Synchronous Code: Task func upadeImg() {
    Task {
        let image = await fetchImageData()
        MainActor.run {
            // Update UI
        }
    }
} To create an asynchronous function, simply use the construct like or . This may help you if you want to use async/await at the network layer with iOS before version 15 and after 13. Converting a Function with a Callback to Asynchronous: withCheckedContinuation withCheckedThrowingContinuation extension URLSession {
    func asyncDataRequest(url: URL) async throws -> Data {
        try await withCheckedThrowingContinuation { next in
            dataTask(with: url, completionHandler: { data, response, error in
                if let error {
                    next.resume(throwing: error)
                } else if let data {
                    next.resume(returning: data)
                } else {
                    next.resume(throwing: NSError(domain: "Empty data", code: 0))
                }
            }).resume()
        }
    }
} Use constructs like or or to execute multiple asynchronous methods concurrently, reducing lines of code and improving efficiency. Running Multiple Queries in Parallel: async let withTaskGroup withThrowingTaskGroup func fetchUser() async -> User {
    async let imageData = await fetchImageData()
    async let fullName = await fetchUserFullName()
    
    return await User(avatar: imageData, fullName: fullName)
} or withTaskGroup func fetchImages(imageID: [String]) async -> [Data] {
    await withTaskGroup(of: Data.self) { group in
        imageID.forEach { id in
            group.addTask {
                await fetchImageData(byID: id)
            }
        }
        
        return await group.reduce(into: [Data]()) { tmpResult, imageData in
            tmpResult.append(imageData)
        }
    }
} Conclusion Async/await in Swift presents a powerful and readable approach to asynchronous programming in iOS applications. By following the outlined steps, developers can simplify their asynchronous code, improve app responsiveness, and leverage Swift's robust asynchronous programming capabilities to create more efficient and responsive iOS apps

Tricks for Using Async/Await in iOS Development

This paper is available on arxiv under CC BY-NC-SA 4.0 DEED license. Authors: (1) Ke Hong, Tsinghua University & Infinigence-AI; (2) Guohao Dai, Shanghai Jiao Tong University & Infinigence-AI; (3) Jiaming Xu, Shanghai Jiao Tong University & Infinigence-AI; (4) Qiuli Mao, Tsinghua University & Infinigence-AI; (5) Xiuhong Li, Peking University; (6) Jun Liu, Shanghai Jiao Tong University & Infinigence-AI; (7) Kangdi Chen, Infinigence-AI; (8) Yuhan Dong, Tsinghua University; (9) Yu Wang, Tsinghua University. Table of Links Abstract & Introduction Backgrounds Asynchronized Softmax with Unified Maximum Value Flat GEMM Optimization with Double Buffering Heuristic Dataflow with Hardware Resource Adaption Evaluation Related Works Conclusion & References 3 Asynchronized Softmax with Unified Maximum Value The partial softmax operation requires synchronization among different partial vectors, leading to ∼20% overheads of the attention operation. As is shown in Figure 2, the synchronization is required after the maximum value of the partial vector is calculated. The maximum value is used to update previous partial softmax (i.e., recompute previous attention) results. Thus, to reduce synchronization overheads, Motivation. the key problem to be solved is how to compute each partial softmax result without requiring results from other partial softmax computation. The reason that synchronization is required lies in that the maximum value of each partial vector is different. The maximum value is used to avoid overflow of the exponent operation (f(x) in Figure 4(a)), and exponents are summed (l(x) in Figure 4(a)) as the denominator of the softmax operation. Such a non-linear operation on each partial maximum value makes the synchronization among each partial softmax computation unavoidable. Challenge. According to the formula of softmax computation, the maximum value is used as the scaling factor for both the numerator and the denominator (i.e., f(x) and l(x) in Figure 4(a)). Our key insight is, the scaling factor can be an arbitrary number rather than using the maximum value mathematically, shown in Equation (3). When we set ϕ = 0, it becomes the original softmax computation [30]. Analysis and Insights. However, the scaling factor cannot be an arbitrary number considering the overflowing of the exponent computation. For the case where xi ≫ ϕ, e xi−ϕ overflows and cannot be represented using a fix-width floating point number (e.g., float32 for exponent results in current LLM engines). For another case where xi ≪ ϕ, e xi−ϕ → 0, leading to precision loss. Thus, a proper scaling factor ϕ should be carefully selected to avoid the two cases above. Figure 5 shows the statistical distribution of xi (elements in the input vectors of softmax) in typical LLMs with different inputs [31]. Our key insight is, > 99.99% xi Specifically, for Llama2-7B, we have −16.8 < xi < 6.5 for > 99.99% xi . Because e b−a and e a−b can be represented by a float32 format, we can set ϕ = a in Equation (3). For OPT-6.7B, we do not apply the technique in this section because of the large range in Figure 5. are within a certain range. Based on the insights above, each partial softmax computation shares a unified maximum value, ϕ. After the softmax operation, an inner product operation is executed between the softmax result and a column of V (i.e., v). Assume that the input vector x can be divided into p partial vectors, x = [x (1), ..., x(p) ] (v = [v (1), ..., v(p) ] correspondingly), we have: Approach: Asynchronization. The inner accumulation in both the numerator and the denominator only take the partial vectors x (j) and v (j) as input, thus they can be processed asynchronously and individually. The outer accumulation is only processed after all partial vectors are processed. As we can see in Figure 4(c), each f(x (j) ) is calculated individually, and sof tmax(x) is calculated after all x (j) is calculated. Without loss of generality, we assume a < xi − ϕ < b for each xi to ensure precision and avoid overflow. Then, the partial softmax operation is processed individually. However, when xi − ϕ ≤ a or xi − ϕ ≥ b, the asynchronized partial softmax computation is terminated for the vector x where xi belongs to. The softmax is then recomputed using the synchronized partial softmax scheme (used in FlashAttention [18, 19] and FlashDecoding [13]) shown in Figure 4(b). Such a recomputation scheme avoids overflow while introducing negligible overheads based on the statistical data shown in Figure 5. Approach: Recomputation.

FlashDecoding++: Faster Large Language Model Inference on GPUs: Asynchronized Softmax with Unified

Handling asynchronous operations in Javascript is a fundamental part of creating responsive and interactive web applications. allows tasks like API calls, file reading, or timers to run in the background, ensuring the application remains responsive. Enter JavaScript Promises, a powerful abstraction for managing these asynchronous operations. Asynchronous programming The Basics of Promises A in JavaScript represents the eventual completion (or failure) of an asynchronous operation and its resulting value. A promise can be in one of three states: Promise : The initial state where the operation has not been completed yet. Pending : The operation was completed successfully. Fulfilled : The operation failed. Rejected Structure of a Promise The basic syntax for creating a promise is: const myPromise = new Promise((resolve, reject) => {
  // Asynchronous operation here
  if (/* operation successful */) {
    resolve('Success');
  } else {
    reject('Error');
  }
}); Creating and Using Promises Creating a promise involves passing an executor function to the Promise constructor, which contains the asynchronous operation and dictates whether the promise should be resolved or rejected. Using Promises Once a promise is created, it can be used with , , and methods to handle the fulfilled or rejected state. then() .catch() .finally() myPromise
  .then((value) => {
    // Handle success
    console.log(value);
  })
  .catch((error) => {
    // Handle error
    console.error(error);
  })
  .finally(() => {
    // Execute cleanup or final operations
    console.log('Completed');
  }); allows you to chain multiple promises, creating a sequence of asynchronous operations that execute one after the other. .then() Error Handling in Promises Proper error handling is crucial in asynchronous programming to ensure the reliability and robustness of web applications. Promises provide a clean and straightforward way to catch and handle errors. Using .catch() The .catch() method is used to handle any errors that occur in the promise chain. fetch('https://api.example.com/data')
  .then(response => response.json())
  .catch(error => console.error('Failed to fetch data:', error)); Error propagation in promises ensures that if an error is not caught by a in the chain, it will bubble up to the next . .catch() .catch() Advanced Promise Features Promises in JavaScript offer more than just basic functionality. There are several advanced features designed to handle complex asynchronous patterns efficiently. Promise.all() When you need to run multiple promises in parallel and wait for all of them to complete, is incredibly useful. Promise.all() Promise.all([promise1, promise2, promise3])
  .then((results) => {
    // results is an array of each promise's result
    console.log(results);
  })
  .catch((error) => {
    // If any promise is rejected, catch the error
    console.error("A promise failed to resolve", error);
  }); Promise.race() is similar to , but it resolves or rejects as soon as one of the promises in the iterable resolves or rejects, with the value or reason from that promise. Promise.race() Promise.all() Promise.race([promise1, promise2, promise3])
  .then((value) => {
    // Value of the first resolved promise
    console.log(value);
  })
  .catch((error) => {
    // Error of the first rejected promise
    console.error(error);
  }); Promise.allSettled() This method returns a promise that resolves after all of the given promises have either been resolved or rejected, with an array of objects that each describe the outcome of each promise. Promise.allSettled([promise1, promise2, promise3])
  .then((results) => {
    results.forEach((result) => console.log(result.status));
  }); Promise.any() takes an iterable of Promise objects and, as soon as one of the promises in the iterable fulfills, returns a single promise that resolves with the value from that promise. Promise.any() Promise.any([promise1, promise2, promise3])
  .then((value) => {
    console.log(value);
  })
  .catch((error) => {
    console.error('All promises were rejected');
  }); Real-world Use Cases for Promises Promises are not just theoretical constructs but have practical applications in everyday programming. Here are a couple of examples: Fetching Data from an API One common use case is fetching data from a remote API: fetch('https://api.example.com/data')
  .then(response => response.json())
  .then(data => console.log(data))
  .catch(error => console.error('Fetch error:', error)); Wrapping Callback-based APIs Another practical use is to wrap callback-based functions (like those in Node.js) into promises for a cleaner, more modern API usage: const fs = require('fs').promises;

fs.readFile('path/to/file.txt', 'utf8')
  .then(data => console.log(data))
  .catch(error => console.error('Read file error:', error)); Promises vs. Async/Await While promises are powerful on their own, the async/await syntax introduced in ES2017 provides a more straightforward way to work with asynchronous operations, making your code cleaner and easier to understand. async function fetchData() {
  try {
    const response = await fetch('https://api.example.com/data');
    const data = await response.json();
    console.log(data);
  } catch (error) {
    console.error('Fetch error:', error);
  }
} async/await is syntactic sugar over promises and can be used wherever promises are used. Best Practices and Common Mistakes To make the most out of promises, here are some best practices and common pitfalls to avoid: Just like callback hell, promise chains can become nested and complicated. Use Promise.all() or async/await to keep your code clean and readable. Avoid Promise Hell: Unhandled promise rejections can cause hard-to-find bugs. Always use .catch() or try/catch with async/await. Always Catch Errors: Remember to return promises from your .then() handlers to keep the chain going. Chain Properly: Conclusion JavaScript promises are a robust tool for handling asynchronous operations, offering a more manageable approach to callbacks. By understanding and leveraging promises, you can write cleaner, more efficient JavaScript code. Keep experimenting with promises and async/await to find the patterns that work best for your applications. Also published . here

Mastering Asynchronous JavaScript: An In-Depth Guide to JavaScript Promises and Best Practices

Introduction: The sheer volume of link sharing online allows ideas, news, and more to spread rapidly across the web. At the same time, as link sharing has exploded, so have the links that spread malware, steal data, and enable hacking attacks. Scams often involve users receiving sketchy links that aim to compromise account information. To address this growing threat, tech companies now commonly use for their users to review the shared link. link preview services But why do you want users to preview the link before clicking? : To obtain a visual preview of the content, they will access it by clicking on the link. This allows users to have an idea of the contents of the URL, which can help them decide if they want to open the link or not. Visual Preview of the link content : To notify users before clicking on malicious content. Prevent from clicking malicious content Generally, link scanners help to check the links against databases of reported threats, helping to identify & notify dangerous links. This helps users avoid becoming victims of scams and hacking attacks. Though no solution can be 100% accurate, link previews that include link scanning have become an essential line of defense in an interconnected world where users share links constantly. You can have a look , where we discussed the benefits of enabling Secure Link Previews within applications. here ApyHub has Link Preview API that helps by: Fetching metadata from any URL passed to include title, description, image, site name, mediaType, contentType, associated images & videos, and favicons. Providing a boolean value as - which indicates whether the URL has been reported as malicious. reported_malicious Enabling frontend applications to make API calls while avoiding request blocks. The process of integrating the is quite straightforward. Let's walk through a practical example using . This hands-on approach will illustrate the process in a real-world context, making it easier to understand and implement. Link Preview API NodeJS Step 1: Set up a NodeJS project. Let’s create a new directory and initialize a NodeJS project. mkdir link-preview-api-example
cd link-preview-api-example Step 2: Install the required libraries. To install all the required dependencies, run this command on the terminal of your project folder. npm init -y
npm install axios Once we run it initializes a new Node.js project by automatically creating a file with default values. command triggers the installation of the Axios dependency. npm init -y 'package.json' npm install axios : It’s a robust library pivotal for making HTTP requests. We will use this for communicating with the Link Preview API. Axios Step 3: Create a file named in your project folder. linkPreview.js The next step is to create a new file; for example, create a file and write the logic function of sending the URL to Link Preview API. linkPreview.js // linkPreview.js

const axios = require('axios');

const apiUrl = 'https://api.apyhub.com/extract/url/preview';

const requestData = {
url:'https://press.farm/founder-ceo-netflix-reed-hastings-definitive-startup-guide-successful-entrepreneurs/', //required
  User_agent: 'google-bot',
  accept_language: 'en-US',
  images_property_type: 'twitter',
  secure_mode: true,
  allow_redirect: true
};

const headers = {
  'Content-Type': 'application/json',
  'apy-token': 'YOUR-APY-TOKEN'
};

axios.post(apiUrl, requestData, { headers })
  .then(response => {
    console.log('Link Preview API Response:', response.data);
  })
  .catch(error => {
    console.error('Error:', error.message);
  }); Let’s understand the requested data inputs and their purpose. Parameter Description URL The URL of the webpage for which you want to generate a preview. images_property_type Fetches images only with the specific property. ( Twitter or OG) user_agent The User-Agent header value of the HTTP request. (ex: user_agent: "google-bot") secure_mode If set to false, disables a safety check for malicious URLs and reports any found threats. This is true by default for user protection. accept_language Specify the language for the HTTP request, such as "en-US" allow_redirects If set to true, It allows redirects to a maximum of one URL, e.g. → https://google.com/ https://www.google.com/ Step 4: Run the project Once done with adding the Link Preview API interface, you can now test the implementation. In your terminal, run: node index.js Step 5: Once the request is sent, the response will be returned in JSON. Link Preview API Response:{
  "data": {
"url": "https://press.farm/founder-ceo-netflix-reed-hastings-definitive-startup-guide-successful-entrepreneurs/",
    "title": "Former Netflix CEO, Reed Hastings' Guide for Successful Entrepreneurs",
    "siteName": "Pressfarm",
    "description": "Reed Hastings has overcome his fair share of challenges in his quest to take over the on-demand streaming business. Here's what he's learnt.",
    "mediaType": "article",
    "contentType": "text/html",
    "images": [],
    "videos": [],
    "favicons": [
      "https://press.farm/wp-content/uploads/2018/05/Pressfarm-favicon.jpg"
    ],
    "charset": "UTF-8",
    "reported_malicious": false
  }
} And that's it! It was easy, right? Now, you can confidently preview links in your applications, safeguarding against potentially harmful content. Also, do not forget to handle the errors in case the URL is malformed - in such cases, the API will return appropriate errors. Also published . here

Securing Link Previews in NodeJS: A Guide using ApyHub's Link Preview API

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

    private async Task InitializeAsync()
    {
        //diligently initializing

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

        await Task.Delay(100);
    }
}

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

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

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

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

    public async Task DoSomethingAsync() 
    {
        await _initializeTask;

        // Do something async
    }

    private async Task InitializeAsync()
    {
        //diligently initializing

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

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

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

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

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

        return Convert.ToBase64String(encryptResult.Ciphertext);
    }

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

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

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

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

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

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

Asynchronous Initialization in C#: Overcoming Constructor Limitations

Hello World! Functions are a key feature of programming that allows developers to create modular, reusable code. In this post, we’ll explore the basics of functions in JavaScript, including function declarations, function expressions, and named function expressions. We’ll also discuss the concept of callbacks, a powerful technique used in asynchronous programming to manage the flow of execution and to handle events or responses that are not known in advance. JavaScript Functions in JavaScript A function in JavaScript is a block of code that can be executed on demand. Functions can take input values (called arguments) and can return output values. In JavaScript, functions can be defined using function declarations, function expressions, and arrow functions. Function Declarations A function declaration defines a named function using the following syntax: function functionName(arguments) {
    // function code goes here
    return value;
} The is the name of the function, and are the parameters that the function takes. The function code goes inside the curly braces and the statement specifies the value that the function should return. functionName arguments return Example: function addNumbers(val1, val2) {
    return val1 + val2;
} Function Expressions A function expression defines an unnamed function that is assigned to a variable, using the following syntax: const functionName = function(arguments) {
    // function code goes here
    return value;
}; In this case, the function is defined as an anonymous function and is assigned to the variable . The function code goes inside the curly braces, and the statement specifies the value that the function should return. functionName return Example: const addNumbers = function(val1, val2) {
    return val1 + val2;
} Named Function Expressions A named function expression is similar to a function expression, but it defines a named function that is assigned to a variable, using the following syntax: const func = function functionName(arguments) {
    // function code goes here
    return value;
}; The function has a name ( in this example), which can be useful for debugging. functionName Callbacks in JavaScript A callback is a function that is passed as an argument to another function and is executed by that function when a certain event or condition is met. Callbacks are a powerful technique used in asynchronous programming to manage the flow of execution and to handle events or responses that are not known in advance. Here’s an example of using a callback in JavaScript: function addNumbers(a, b, callback) {
    const sum = a + b;
    callback(sum);
}

function displayResult(result) {
    console.log('The sum is ' + result);
}

addNumbers(5, 10, displayResult); In this example, we call the function with two arguments ( and ) and a callback function . The function calculates the sum of the two arguments and passes the result to the callback function. The callback function then logs the result to the console. addNumbers 5 10 displayResult addNumbers Functions and callbacks are powerful tools in JavaScript that allow developers to create modular, reusable code and manage asynchronous operations. By understanding the basics of functions and callbacks, developers can create efficient and scalable code that can handle complex operations. In addition, understanding how callbacks work is essential for working with APIs, handling user input, and creating interactive web applications. That’s all about the functions and callbacks in JavaScript. I hope you found this useful. Thanks for reading! Also published here.

Stories, News & Mentions about APSY

Apsy’s Stories on HackerNoon