We founded Qflow in May 2018 with the sole purpose of leaving the world in a better place than we found it

Qflow

I started my marketing career at the end of the 2000s. At that time, the digital marketing landscape was scarce and full of uncharted waters. A lot of decisions were based on gut feeling, and the cost of human error was high. There were no solutions in place for many marketing needs due to the lack of technology, so we had to swelter a lot to create kludges and workarounds (while this sparked a lot of creativity, it also significantly slowed down our execution). At that time, we, marketers, could only dream of having someone build a one-stop-shop solution that would automatically analyze all of our campaign data and provide actionable recommendations based on that data. A new AI era we entered in the 2010s made a lot of impossible things possible. Yet, even today, with a plethora of AI-based tools and systems, marketers still have to do the lion's share of the work, focusing on the manual part of their operations rather than strategic decision-making. To get the most out of our campaign data, we still have to rely heavily on data scientists to help translate data into actionable insights. No-code or codeless AI seems to be the solution we've been waiting for for a while. As I was evaluating the current market for no-code AI platforms, I came across . This California-based tech startup provides codeless AI infrastructure to enable customers to scale accurate data-driven marketing. Pixis To better understand how no-code AI works and benefits marketing teams and what marketers need to know before tapping into the codeless AI infrastructure, Ive talked to , CTO and Co-Founder of Pixis. Vrushali Prasade Vrushali is a young entrepreneur with an extensive background in tech. After graduating from university and prior to starting Pixis, she founded Absentia Virtual Reality, which used AI to build a disruptive tech stack for game developers, enabling a faster go-to-market. In 2018, Vrushali co-founded Pixis with Shubham A Mishra and Hari Valiyath, both of whom she'd worked with on numerous AI projects before. In January 2022, Pixis announced it had from Softbank and General Atlantic, along with existing investors, just four months after raising $17 million in Series B.  SoftBank and General Atlantic were the two new investors, with SoftBank leading the round. The total funding attracted to date is $124 million. raised $100 million Enjoy the conversation! Vrushali, what's codeless AI and how can it drive AI commoditization and mass adoption? In very general terms, is a code-free technology that enables non-tech folks to get control of AI solutions through a user-friendly, intuitive interface and build their own models against different parameters. So, basically, it allows anybody to harness the power of AI without being an AI engineer or a data scientist. no-code AI Marketing automation is where AI has recently become a fundamental game changer. Innovative solutions typically go mainstream and become commodities as they become more available to mass users. As such, no-code AI infrastructure has a huge potential to drive AI mass adoption across industries and verticals. What's the current size of the codeless AI market? I've come across some articles in Think Tank saying that as of 2021, codeless AI has generated in revenues and is expected to reach a staggering at a CAGR of between 2022 and 2032. publications $2 billion $38.5 million 28% What're the most critical challenges facing modern marketers, and how can no-code platforms like Pixis help solve them? The critical challenge that many marketers face today is the scaling at which their ideal campaign setup will work perfectly well, allowing them to explore all possible audiences, creative communications, and strategies. They need to make a lot of decisions for their campaign optimization. Human intelligence is still required to fuel the right data into the automation systems, which is laborious and time-consuming. This is where Pixis can be a "rescue ranger": we build a robust no-code AI infrastructure that enables profound depth of insights, allowing marketers to select the exact AI systems or combination of models they need to deploy to improve their marketing outcomes. And recommendations will be unique for their brand only. Once the appropriate systems and models have been selected, all that needs to be done is to activate the AI ​​and watch it ​​begin to learn and act. From a technology perspective, what does it take to build a codeless AI ecosystem for marketers? There're three core elements at the foundation of codeless AI development. First, it's the proper data sync. Our AI infrastructure enables a host of integrations with 3rd party platforms. It fetches data from these platforms at the required scale for our AI systems to analyze. Second, it's a combination of AI and engineering services to build meaningful connections between users and AI dashboards. The third would be the execution of whatever decision has been made based on the AI recommendations and ensuring it happens at the right time, with the right events, etc. From the languages and frameworks point of view, we mainly use Python and MERN stack for the backend (data and AI models), and React and Nodejs for the application's front end. Most of our infrastructure is hosted on AWS. For deployment standardization, we use EKS, Kubernetes, and other tools. We've recently started exploring QFlow for our deployment pipeline automation. Pixes Founders: Shubham A Mishra (CEO), Vrushali Prasade (CTO), and Hari Valiyath (CBO) From a user perspective, how do you make a difference compared to similar codeless AI solution providers? Let's look at other no-code AI solutions available in the market today. The present landscape mainly consists of two types of players. The first have built their own robust AI tech that is able to provide a set of recommendations to marketers, who then make decisions based on those recommendations and apply them to their campaigns. However, these solutions aren't actionable in nature. The latter provide rule-based solutions, not really powered by AI, which restricts insights generation for marketers. What Pixis does differently is as follows. Our AI infrastructure has a self-evolving or contextual nature with a robust feedback mechanism. So, basically, what happens is that our AI systems constantly communicate with each other. This leads to the infrastructure growing and evolving along with a brand's audience. In essence, the infrastructure generates insights and takes actions unique to each brand. And what should marketers know before tapping into the no-code AI infrastructure? Any pitfalls to be aware of? I believe one of the most important things is to make sure that you shift your whole marketing approach from operations-first to a strategic one. In the past, to of marketers' efforts were spent monitoring their campaign performance, making decisions like whether to increase or decrease the budget, which campaigns to turn off, etc. Even today, for most marketers, about of their time is still spent on operational activities, which takes them away from their strategic focus. 40% 50% 50% Before harnessing the power of codeless AI, marketers need to start thinking broadly and realistically. At the end of the day, most manual jobs they did in the past and still do now will eventually be replaced by AI-based intelligence solutions, leaving them with a lot of time on their hands to concentrate on strategic decision-making and experimentation at scale. Based on your experience, what's the current level of codeless AI adoption among marketers? And what prevents most marketing teams from taking this path and jumping on the codeless AI bandwagon? Typically, multiple stakeholders are involved in running a marketing campaign. Brand managers make decisions about the communication and creative part of the campaigns. Digital marketers work day to day on campaign optimization. Others make decisions about media buying budgets and planning, etc. The more people are involved in a process, the more difficult it is to promote a new way of doing things and get their buy-in. As such, multiple stakeholders contributing to one major decision pose a challenge to new platform adoption. We tried to pinpoint and address this issue by creating the right product experiences that would cater to multiple marketing stakeholders, which can help facilitate a new automation-driven approach. From a marketing manager's standpoint, they have to spend a boatload of time learning the ins and outs of each marketing platform they're going to work with. There're a lot of books and courses on Facebook Marketing or Google Marketing, so they really have to invest a lot of effort into expanding their knowledge and gaining first-hand experience with those tools and platforms. So, whenever a new solution pops up that requires a steep learning curve from them, it's the solution provider's responsibility to make sure this new learning curve aligns with their existing user experience and work approaches. We've seen a couple of companies with good AI offerings but a highly complex user experience, which can hold back mass adoption, too. As such, it's both a challenge and an opportunity for us, innovative platform providers, to educate people in data-driven marketing and show them the clear benefits of shifting their marketing mindset to be more automation-focused. What's your typical customer portrait? At present, Pixis is targeting large, enterprise-level customers. Later, we may start building and opening our solutions for SMBs. Our user base is currently split between agencies using Pixis to support their customers, and in-house marketing teams. And what about user data privacy? How reliable is Pixis from a security point of view? Pixis doesn't use personal information (PI) at all. Our solutions are based on the aggregated data and provide insights at the cohort level. There're three core solutions we offer: makes decisions around the budgets and metrics, it is the AI system that is also responsible for continuously communicating and providing feedback to the rest of the AI systems. It governs the entire process allowing for real-time strategy updates with targeting and communication delivery; Governance AI deals with media planning, customer behavior and engagement feedback; Targeting AI deals with generation of contextual text and creative assets. Creative AI All the recommendations are provided at the cohort rather than individual level. All insights we generate for brands are also based on aggregated data and don't require any PI ingestion. Our AI looks into particular industry trends, analyzes the tone of voice and other indicators, and generates actionable campaign optimization and improvement recommendations. Of course, when working with brands, we may have to ingest some of their proprietary data to the core of our AI so that it can learn from it. Whenever we do it, we set up complex API-based integrations and never actually take the customer data away from their original sources. Pixis has raised an impressive $124 million in funding. That's a real success story. What piece of advice would you give to fellow entrepreneurs who're just at the start of their fundraising journey? The key driver of attracting the funding was our steady growth in revenue, customer expansion, pipeline of AI products in R&D and the clarity of vision we hold for Pixis. The scale and rate at which we were growing and developing our codeless AI infrastructure seems very exciting for investors. Our main pitch was based on the comparisons of how marketing teams operated in  the past versus how they can operate now with the help of Pixis. The numbers we shared spoke for themselves. For instance, many customers who use our products have seen areduction of their customer acquisition costs by . 40%-50% When you want to hit the market with an innovative solution, you often can't resist the temptation to help solve a dozen different problems. My advice for fellow entrepreneurs would be to figure out one core problem plaguing their target audience and pinpoint solutions tailored specifically to solve it. We had the same situation at Pixis – initially, we intended to help marketers solve as many problems as possible with AI. Yet, once we figured out our core problem statement, it became a game changer for us. So my advice would be, find your key hook and let your solutions blossom out from there in a logical and directional manner. From your perspective, do you believe AI will eventually take over human intelligence, or how will humans coexist with AI in the future? From a human standpoint, if we look at it historically, thousands of years ago, physical strength was valued a lot, as it was essential for survival. Then, over time, engineering solutions like a wheel helped humans get away from laborious physical work to machine-based activity. That was the beginning of an IQ era. Today, we're basically going through very similar transformations, moving from machine-based activities to intelligent automation. However, we still need human intelligence to make strategic decisions in our . As such, AI is just another tool for us to improve our job in a more precise and reliable way. AI era So, answering your question, I don't think AI will take over humans. However, people will have to learn many new things to harness the power of AI and operate it in a risk-free environment. An exciting path is ahead of us, isn't it? Dear Reader, this year, I've been  nominated to 4 Noonies 2022 Awards in the following categories: Hackernoon Contributor of the Year – Founder Interview , Innovation , Hacking and Robotics . I’d really appreciate your support and votes! Thank You!

No-Code AI In Marketing: A Shift In Mindset?

This paper is available on arxiv under CC 4.0 license.
Authors:
(1) Zheyu Oliver Wang, Department of Aeronautics and Astronautics, Massachusetts Institute of Technology, Cambridge, MA and olivrw@mit.edu;
(2)  Ricardo Baptista, Computing + Mathematical Sciences, California Institute of Technology, Pasadena, CA and rsb@caltech.edu;
(3) Youssef Marzouk, Department of Aeronautics and Astronautics, Massachusetts Institute of Technology, Cambridge, MA and ymarz@mit.edu;
(4) Lars Ruthotto, Department of Mathematics, Emory University, Atlanta, GA and lruthotto@emory.edu;
(5) Deepanshu Verma, Department of Mathematics, Emory University, Atlanta, GA and deepanshu.verma@emory.edu. Table of Links Abstract & Introduction
Background and Related Work
Partially Convex Potential Maps (PCP-Map) for Conditional OT
Conditional OT flow (COT-Flow)
Implementation and Experimental Setup
Numerical Experiments
Discussion and Reference 4. Conditional OT flow (COT-Flow). In this section, we extend the OT-regularized continuous normalizing flows in [36] to the conditional generative modeling problem introduced in section 2. Training Problem. Following the general approach of continuous normalizing flows [11, 19], we express the transport map that pushes forward the reference distribution ρz to the target π(x|y) via the flow map of an ODE. That is, we define g(z, y) = u(1) as the terminal state of the ODE where the evolution of u: [0, 1] → R n depends on the velocity field v : [0, 1] × R n × R m → R n and will be parameterized with a neural network below. When the velocity is trained to minimize the negative log-likelihood loss in (3.2), the resulting mapping is called a continuous normalizing flow [19]. We add y as an additional input to the velocity field to enable conditional sampling. Consequently, the resulting flow map and generator g depend on y. One advantage of defining the generator through an ODE is that the loss function can be evaluated efficiently for a wide range of velocity functions. Recall that the loss function requires the inverse of the generator and the log-determinant of its Jacobian. For sufficiently regular velocity fields, the inverse of the generator can be obtained by integrating backward in time. To be precise, we define g −1 (x, y) = p(0) where p : [0, 1] → R n satisfies (4.1) with the terminal condition p(1) = x. As derived in [58, 19, 56], constructing the generator through an ODE also simplifies computing the log-determinant of the Jacobian, i.e., Penalizing transport costs during training leads to theoretical and numerical advantages; see, for example, [58, 56, 36, 17]. Hence, we consider the OT-regularized training problem where α1 > 0 is a regularization parameter that trades off matching the distributions (for α1 ≪ 1) and minimizing the transport costs (for α1 ≫ 0) given by the dynamic transport cost penalty This penalty is stronger than the static counterpart in (3.4), in other words However, the values of both penalties agree when the velocity field in (4.1) is constant along the trajectories, which is the case for the optimal transport map. Hence, we expect the solution of the dynamic problem to be close to that of the static formulation when α1 is chosen well. To provide additional theoretical insight and motivate our numerical method, we note that (4.3) is related to the potential mean field game (MFG) Here, the terminal and running costs in the objective functional are the L2 anti-derivatives of JNLL and PDOT, respectively, and the continuity equation is used to represent the density evolution under the velocity v. To be precise, (4.3) can be seen as a discretization of (4.6) in the Lagrangian coordinates defined by the reversed ODE (4.14). Note that both formulations differ in the way the transport costs are measured: (4.4) computes the cost of pushing the conditional distribution to the Gaussian, while (4.6) penalizes the costs of pushing the Gaussian to the conditional. While these two terms do not generally agree, they coincide for the L2 optimal transport map; see [16, Corollary 2.5.13] for a proof for unconditional optimal transport. For more insights into MFGs and their relation to optimal transport and generative modeling, we refer to our prior work [43] and the more recent work [57, Sec 3.4]. The fact that the solutions of the microscopic version in (4.3) and the macroscopic version in (4.6) agree is remarkable and was first shown in the seminal work [28]. By Pontryagin’s maximum principle, the solution of (4.3) satisfies the feedback form where Φ : [0, 1] × R n × R m → R and Φ(·, ·, y) can be seen as the value function of the MFG and, alternatively, as the Lagrange multiplier in (4.6) for a fixed y. Therefore, we model the velocity as a conservative vector field as also proposed in [36, 43]. This also simplifies the computation of the log-determinant since the Jacobian of v is symmetric, and we note that Another consequence of optimal control theory is that the value function satisfies the Hamilton Jacobi Bellman (HJB) equations with the terminal condition which is only tractable if the joint density, π(x, y), is available. These n-dimensional PDEs are parameterized by y ∈ R m. Neural network approach. We parameterize the value function, Φ, with a scalar-valued neural network. In contrast to the static approach in the previous section, the choice of function approximator is more flexible in the dynamic approach. The approach can be effective as long as Φ is parameterized with any function approximation tool that is effective in high dimensions, allows efficient evaluation of its gradient and Laplacian, and the training problem can be solved sufficiently well. For our numerical experiments, we use the architecture considered in [36] and model Φ as the sum of a simple feed-forward neural network and a quadratic term. That is, As in [36], we model the neural network as a two-layer residual network of width w that reads Sample generation. After training, we draw i.i.d. samples from the approximated conditional distribution for a given y by sampling z ∼ ρz and solving the ODE (4.1). Since we train the inverse generator using a fixed number of integration steps, nt, it is interesting to investigate how close our solution is to the continuous problem. One indicator is to compare the samples obtained with different number of integration steps during sampling. Another indicator is to compute the variance of ∇Φ along the trajectories. Hyperparameters. As described in section 5, we randomly sample the width, w, of the neural network, the number of time integration steps during training, the penalty parameters α1, α2, and the hyperparameters of the Adam optimizer (batch size and initial learning rate) from the values listed in Table 2. This paper is available on arxiv under CC 4.0 license. Authors: (1) Zheyu Oliver Wang, Department of Aeronautics and Astronautics, Massachusetts Institute of Technology, Cambridge, MA and olivrw@mit.edu; (2)  Ricardo Baptista, Computing + Mathematical Sciences, California Institute of Technology, Pasadena, CA and rsb@caltech.edu; (3) Youssef Marzouk, Department of Aeronautics and Astronautics, Massachusetts Institute of Technology, Cambridge, MA and ymarz@mit.edu; (4) Lars Ruthotto, Department of Mathematics, Emory University, Atlanta, GA and lruthotto@emory.edu; (5) Deepanshu Verma, Department of Mathematics, Emory University, Atlanta, GA and deepanshu.verma@emory.edu. This paper is available on arxiv under CC 4.0 license. Authors: Authors: (1) Zheyu Oliver Wang, Department of Aeronautics and Astronautics, Massachusetts Institute of Technology, Cambridge, MA and olivrw@mit.edu; (2)  Ricardo Baptista, Computing + Mathematical Sciences, California Institute of Technology, Pasadena, CA and rsb@caltech.edu; (3) Youssef Marzouk, Department of Aeronautics and Astronautics, Massachusetts Institute of Technology, Cambridge, MA and ymarz@mit.edu; (4) Lars Ruthotto, Department of Mathematics, Emory University, Atlanta, GA and lruthotto@emory.edu; (5) Deepanshu Verma, Department of Mathematics, Emory University, Atlanta, GA and deepanshu.verma@emory.edu. Table of Links Abstract & Introduction Background and Related Work Partially Convex Potential Maps (PCP-Map) for Conditional OT Conditional OT flow (COT-Flow) Implementation and Experimental Setup Numerical Experiments Discussion and Reference Abstract & Introduction Abstract & Introduction Background and Related Work Background and Related Work Partially Convex Potential Maps (PCP-Map) for Conditional OT Partially Convex Potential Maps (PCP-Map) for Conditional OT Conditional OT flow (COT-Flow) Conditional OT flow (COT-Flow) Implementation and Experimental Setup Implementation and Experimental Setup Numerical Experiments Numerical Experiments Discussion and Reference Discussion and Reference 4. Conditional OT flow (COT-Flow). In this section, we extend the OT-regularized continuous normalizing flows in [36] to the conditional generative modeling problem introduced in section 2. Training Problem. Following the general approach of continuous normalizing flows [11, 19], we express the transport map that pushes forward the reference distribution ρz to the target π(x|y) via the flow map of an ODE. That is, we define g(z, y) = u(1) as the terminal state of the ODE where the evolution of u: [0, 1] → R n depends on the velocity field v : [0, 1] × R n × R m → R n and will be parameterized with a neural network below. When the velocity is trained to minimize the negative log-likelihood loss in (3.2), the resulting mapping is called a continuous normalizing flow [19]. We add y as an additional input to the velocity field to enable conditional sampling. Consequently, the resulting flow map and generator g depend on y. One advantage of defining the generator through an ODE is that the loss function can be evaluated efficiently for a wide range of velocity functions. Recall that the loss function requires the inverse of the generator and the log-determinant of its Jacobian. For sufficiently regular velocity fields, the inverse of the generator can be obtained by integrating backward in time. To be precise, we define g −1 (x, y) = p(0) where p : [0, 1] → R n satisfies (4.1) with the terminal condition p(1) = x. As derived in [58, 19, 56], constructing the generator through an ODE also simplifies computing the log-determinant of the Jacobian, i.e., Penalizing transport costs during training leads to theoretical and numerical advantages; see, for example, [58, 56, 36, 17]. Hence, we consider the OT-regularized training problem where α1 > 0 is a regularization parameter that trades off matching the distributions (for α1 ≪ 1) and minimizing the transport costs (for α1 ≫ 0) given by the dynamic transport cost penalty This penalty is stronger than the static counterpart in (3.4), in other words However, the values of both penalties agree when the velocity field in (4.1) is constant along the trajectories, which is the case for the optimal transport map. Hence, we expect the solution of the dynamic problem to be close to that of the static formulation when α1 is chosen well. To provide additional theoretical insight and motivate our numerical method, we note that (4.3) is related to the potential mean field game (MFG) Here, the terminal and running costs in the objective functional are the L2 anti-derivatives of JNLL and PDOT, respectively, and the continuity equation is used to represent the density evolution under the velocity v. To be precise, (4.3) can be seen as a discretization of (4.6) in the Lagrangian coordinates defined by the reversed ODE (4.14). Note that both formulations differ in the way the transport costs are measured: (4.4) computes the cost of pushing the conditional distribution to the Gaussian, while (4.6) penalizes the costs of pushing the Gaussian to the conditional. While these two terms do not generally agree, they coincide for the L2 optimal transport map; see [16, Corollary 2.5.13] for a proof for unconditional optimal transport. For more insights into MFGs and their relation to optimal transport and generative modeling, we refer to our prior work [43] and the more recent work [57, Sec 3.4]. The fact that the solutions of the microscopic version in (4.3) and the macroscopic version in (4.6) agree is remarkable and was first shown in the seminal work [28]. By Pontryagin’s maximum principle, the solution of (4.3) satisfies the feedback form where Φ : [0, 1] × R n × R m → R and Φ(·, ·, y) can be seen as the value function of the MFG and, alternatively, as the Lagrange multiplier in (4.6) for a fixed y. Therefore, we model the velocity as a conservative vector field as also proposed in [36, 43]. This also simplifies the computation of the log-determinant since the Jacobian of v is symmetric, and we note that Another consequence of optimal control theory is that the value function satisfies the Hamilton Jacobi Bellman (HJB) equations with the terminal condition which is only tractable if the joint density, π(x, y), is available. These n-dimensional PDEs are parameterized by y ∈ R m. Neural network approach. We parameterize the value function, Φ, with a scalar-valued neural network. In contrast to the static approach in the previous section, the choice of function approximator is more flexible in the dynamic approach. The approach can be effective as long as Φ is parameterized with any function approximation tool that is effective in high dimensions, allows efficient evaluation of its gradient and Laplacian, and the training problem can be solved sufficiently well. For our numerical experiments, we use the architecture considered in [36] and model Φ as the sum of a simple feed-forward neural network and a quadratic term. That is, As in [36], we model the neural network as a two-layer residual network of width w that reads Sample generation. After training, we draw i.i.d. samples from the approximated conditional distribution for a given y by sampling z ∼ ρz and solving the ODE (4.1). Since we train the inverse generator using a fixed number of integration steps, nt, it is interesting to investigate how close our solution is to the continuous problem. One indicator is to compare the samples obtained with different number of integration steps during sampling. Another indicator is to compute the variance of ∇Φ along the trajectories. Hyperparameters. As described in section 5, we randomly sample the width, w, of the neural network, the number of time integration steps during training, the penalty parameters α1, α2, and the hyperparameters of the Adam optimizer (batch size and initial learning rate) from the values listed in Table 2.

Efficient Neural Network Approaches for Conditional Optimal Transport:Conditional OT flow (COT-Flow)

Exceptions are designed to handle unexpected situations rather than controlling the application flow. Using exceptions during input validation can affect your application's readability and performance. Learning Objectives The inefficient use of exceptions
A better approach using TryParse Prerequisites for Developers Basic understanding of C# programming language. 30 Day .Net Challenge Getting Started The inefficient use of exceptions Using exceptions for flow control, especially in a loop or frequently called code, may lead to severe performance bottlenecks. It also makes code hard to understand. Exceptions are really expensive in terms of system resources because when an exception is triggered, .Net runtime captures the stack trace and the process is resource-intensive. try
    {
        int.Parse(input); // Attempt to parse input
    }
    catch (FormatException)
    {
        // Handle the invalid input
    } A better approach using TryParse Please find below the refactored version of the previous code snippet if (int.TryParse(input, out int result))
    {
        // Use the parsed value
    }
    else
    {
        // Handle the invalid input
    } The aforementioned code attempts to parse the input supplied from the console and returns a boolean whether it's a success or failure. Complete Code Create another class named AvoidExceptions and add the following code snippet public static class AvoidExceptions
    {
        public static void BadWay(string input)
        {
            // Inefficient way: Using exceptions for flow control
            try
            {
                int number = int.Parse(input);
                Console.WriteLine($"You entered (Exception method): {number}");
            }
            catch (FormatException)
            {
                Console.WriteLine("Invalid input! Please enter a valid integer.");
            }
        }
    
        public static void GoodWay(string input)
        {
            // Efficient way: Using TryParse for flow control
            if (int.TryParse(input, out int result))
            {
                Console.WriteLine($"You entered (TryParse method): {result}");
            }
            else
            {
                Console.WriteLine("Invalid input! Please enter a valid integer.");
            }
        }
    } Execute from the main method as follows #region Day 24: Avoid Exceptions in Flow Control
    static string ExecuteDay24()
    {
        Console.WriteLine("Enter a number:");
    
        string input = Console.ReadLine();
        AvoidExceptions.BadWay(input);
        AvoidExceptions.GoodWay(input);
        return "Executed Day 24 successfully..!!";
    }
    
    #endregion Console Output Invalid input! Please enter a valid integer.
    Invalid input! Please enter a valid integer. Complete Code here: GitHub — ssukhpinder/30DayChallenge.Net C# Programming🚀 Thank you for being a part of the C# community! Before you leave: Follow us: Youtube | X | LinkedIn | Dev.to Visit our other platforms: GitHub More content at C# Programming Exceptions are designed to handle unexpected situations rather than controlling the application flow. Using exceptions during input validation can affect your application's readability and performance. Learning Objectives The inefficient use of exceptions A better approach using TryParse The inefficient use of exceptions A better approach using TryParse Prerequisites for Developers Basic understanding of C# programming language. Basic understanding of C# programming language. C# programming language. 30 Day .Net Challenge 30 Day .Net Challenge Getting Started The inefficient use of exceptions Using exceptions for flow control, especially in a loop or frequently called code, may lead to severe performance bottlenecks. It also makes code hard to understand. Exceptions are really expensive in terms of system resources because when an exception is triggered, .Net runtime captures the stack trace and the process is resource-intensive. try
    {
        int.Parse(input); // Attempt to parse input
    }
    catch (FormatException)
    {
        // Handle the invalid input
    } try
    {
        int.Parse(input); // Attempt to parse input
    }
    catch (FormatException)
    {
        // Handle the invalid input
    } A better approach using TryParse Please find below the refactored version of the previous code snippet if (int.TryParse(input, out int result))
    {
        // Use the parsed value
    }
    else
    {
        // Handle the invalid input
    } if (int.TryParse(input, out int result))
    {
        // Use the parsed value
    }
    else
    {
        // Handle the invalid input
    } The aforementioned code attempts to parse the input supplied from the console and returns a boolean whether it's a success or failure. Complete Code Create another class named AvoidExceptions and add the following code snippet public static class AvoidExceptions
    {
        public static void BadWay(string input)
        {
            // Inefficient way: Using exceptions for flow control
            try
            {
                int number = int.Parse(input);
                Console.WriteLine($"You entered (Exception method): {number}");
            }
            catch (FormatException)
            {
                Console.WriteLine("Invalid input! Please enter a valid integer.");
            }
        }
    
        public static void GoodWay(string input)
        {
            // Efficient way: Using TryParse for flow control
            if (int.TryParse(input, out int result))
            {
                Console.WriteLine($"You entered (TryParse method): {result}");
            }
            else
            {
                Console.WriteLine("Invalid input! Please enter a valid integer.");
            }
        }
    } public static class AvoidExceptions
    {
        public static void BadWay(string input)
        {
            // Inefficient way: Using exceptions for flow control
            try
            {
                int number = int.Parse(input);
                Console.WriteLine($"You entered (Exception method): {number}");
            }
            catch (FormatException)
            {
                Console.WriteLine("Invalid input! Please enter a valid integer.");
            }
        }
    
        public static void GoodWay(string input)
        {
            // Efficient way: Using TryParse for flow control
            if (int.TryParse(input, out int result))
            {
                Console.WriteLine($"You entered (TryParse method): {result}");
            }
            else
            {
                Console.WriteLine("Invalid input! Please enter a valid integer.");
            }
        }
    } Execute from the main method as follows #region Day 24: Avoid Exceptions in Flow Control
    static string ExecuteDay24()
    {
        Console.WriteLine("Enter a number:");
    
        string input = Console.ReadLine();
        AvoidExceptions.BadWay(input);
        AvoidExceptions.GoodWay(input);
        return "Executed Day 24 successfully..!!";
    }
    
    #endregion #region Day 24: Avoid Exceptions in Flow Control
    static string ExecuteDay24()
    {
        Console.WriteLine("Enter a number:");
    
        string input = Console.ReadLine();
        AvoidExceptions.BadWay(input);
        AvoidExceptions.GoodWay(input);
        return "Executed Day 24 successfully..!!";
    }
    
    #endregion Console Output Invalid input! Please enter a valid integer.
    Invalid input! Please enter a valid integer. Invalid input! Please enter a valid integer.
    Invalid input! Please enter a valid integer. Complete Code here: GitHub — ssukhpinder/30DayChallenge.Net Complete Code here: GitHub — ssukhpinder/30DayChallenge.Net GitHub — ssukhpinder/30DayChallenge.Net C# Programming🚀 Thank you for being a part of the C# community! Before you leave: Follow us: Youtube | X | LinkedIn | Dev.to Visit our other platforms: GitHub More content at C# Programming Youtube X LinkedIn Dev.to GitHub

The 30-Day .NET Challenge - Day 24: How to Avoid Exceptions in Flow Control

How to Master Authentication and User Flow in Node.js With Knex and Redis

Knex এবং Redis দিয়ে Node.js-এ প্রমাণীকরণ এবং ব্যবহারকারীর প্রবাহ কীভাবে আয়ত্ত করা যায়

So meistern Sie die Authentifizierung und den Benutzerfluss in Node.js mit Knex und Redis

Cómo dominar la autenticación y el flujo de usuarios en Node.js con Knex y Redis

Comment maîtriser l'authentification et le flux d'utilisateurs dans Node.js avec Knex et Redis

Knex और Redis के साथ Node.js में प्रमाणीकरण और उपयोगकर्ता प्रवाह में कैसे महारत हासिल करें

Knex と Redis を使用して Node.js で認証とユーザー フローをマスターする方法

Knex 및 Redis를 사용하여 Node.js에서 인증 및 사용자 흐름을 마스터하는 방법

Como dominar a autenticação e o fluxo do usuário em Node.js com Knex e Redis

Как освоить аутентификацию и поток пользователей в Node.js с помощью Knex и Redis

Knex ve Redis ile Node.js'de Kimlik Doğrulama ve Kullanıcı Akışında Ustalaşma

Cách làm chủ xác thực và luồng người dùng trong Node.js với Knex và Redis

如何使用 Knex 和 Redis 在 Node.js 中掌握身份验证和用户流程

Exploring Dart Control Flow Statement: From If-Else to Loops and More Dive into the world of Dart programming, the fundamental control flow structures of Dart 3, including if-else blocks, if-else-if blocks, switch statements, and switch expressions. Learn how to leverage these constructs effectively in your Dart programs for better control and readability. Read Part 1 of this article here: Exploring Dart Fundamentals - Part 1 Dart Control Flow Statement In Dart, the Control flow statement can be categorized mainly in three ways. Decision-making statements Looping statements Jump statements Initialization and Constants: const temperature = 43; In this line, a constant named is declared and assigned a value of 43. Constants are variables whose values cannot be changed once assigned. Here, represents the temperature value to be evaluated. temperature temperature 1.1 If Block Structure: The “if” statement in programming allows you to execute a block of code if a specified condition is true. It provides a basic branching mechanism where the code block associated with the “if” statement is executed only if the condition evaluates to true. if (temperature < 10) {
    print("Very Cold");
} In this example, the “if” statement checks if the value of the variable “temperature” is less than 10. If the condition is true (temperature is less than 10), it prints “Very Cold” to the console. If the condition is false, the code block associated with the “if” statement is simply skipped, and no further action is taken. 1.1 If-Else Block Structure: The if-else statement in Dart allows you to execute a block of code if a condition is true, and another block if the condition is false. It provides a basic branching mechanism in programming logic. if (temperature < 10){
  print("Very Cold");
} else {
  print("Not very cold");
} This section employs an if-else block to check whether the temperature is less than 10. If the condition is true, the code prints “Very Cold”; otherwise, it prints “Not very cold”. This simple if-else structure provides a straightforward way to handle binary conditions. 1.3 If-Else-If Block Structure: The if-else-if statement extends the if-else statement by allowing you to test multiple conditions sequentially. It provides a way to evaluate complex branching logic where there are multiple possible outcomes. if (temperature < 10) {
  print("Very Cold");
} else if (temperature >= 10 && temperature <= 18) {
  print("Cold");
} else if (temperature >= 10 && temperature <= 24) {
  print("Normal");
} else if (temperature >= 10 && temperature <= 35) {
  print("Hot");
} else if (temperature >= 10 && temperature <= 40) {
  print("Very Hot");
} else {
  print("Really too Hot");
} This section presents a series of if-else-if blocks to evaluate the temperature against specific ranges and determine the appropriate weather conditions. Each condition is mutually exclusive, ensuring that only one condition is met. 1.4 Switch Statement: The switch statement in Dart provides an alternative way to express multi-branching logic. It evaluates an expression against a list of possible cases and executes the code block associated with the first matching case. It’s particularly useful when dealing with multiple possible values for a variable. switch (temperature) {
  case < 10:
    print("Very Cold");
    break;
  case > 10 && <= 18:
    print("Cold");
    break;
  case > 10 && <= 24:
    print("Normal");
    break;
  case > 10 && <= 34:
    print("Hot");
    break;
  case > 10 && <= 40:
    print("Very Cold");
    break;
  default:
    print("Really Too Hot");
    break;
} Here, a switch statement is used to evaluate the temperature and print the corresponding weather condition based on different temperature ranges defined in the cases. However, the use of inequalities within the case labels is not syntactically correct in Dart. This code won’t work as intended. 1.5 Switch Expression in Dart 3: Introduced in Dart 2.3, the switch expression is a concise way to express multi-branching logic. It evaluates an expression against a list of cases, similar to the switch statement, but it returns a value based on the matched case instead of executing code blocks. This enhances readability and conciseness, especially in functional programming contexts. final status = switch(temperature){
  <10 => "very cold",
  >= 10 && <= 18 => "Cold",
  >= 10 && <= 24 => "Normal",
  >= 10 && <= 34 => "Hot",
  >= 10 && <= 40 => "Very Cold",
  _ => "Really Too Hot",
};
print(status); This section showcases the switch expression introduced in Dart 3. It allows for concise pattern matching and assignment of values based on conditions. However, the use of inequalities within the switch expression is also not valid in Dart and will not work as intended. 2.1 While Loop: A while loop is a control flow statement that executes a block of code repeatedly as long as a specified condition evaluates to true. The condition is evaluated before each iteration. If the condition is false initially, the block of code inside the loop is never executed. int index = 1;
while (index < marks.length) {
    print(marks[index]);
    index++;
} The while loop continues to execute as long as the condition evaluates to true. It prints the element at the current index of the list and increments the index by one in each iteration. index < marks.length marks 2.2 Do-While Loop: A do-while loop is similar to a while loop, but the condition is evaluated after the block of code inside the loop is executed. This means that the block of code is executed at least once, regardless of whether the condition is true or false initially. do {
    print(marks[index]);
    index++;
} while (index < marks.length); 2.3 For Loop: A for loop is a control flow statement that iterates over a range of values. It typically includes an initialization step, a condition for continuing the loop, and an iteration step. The loop iterates until the condition becomes false. for (int i = 0; i < marks.length; i++) {
    print(marks[i]);
} The for loop is used to iterate over the elements of the list. It initializes the loop control variable to 0 and continues to execute as long as is less than the length of the list. In each iteration, it prints the element at the index of the list and increments by one. marks i i marks i i 3. Break and Continue is used to immediately exit the loop when a specific condition is met. break is used to skip the remaining code in the current iteration of the loop and proceed to the next iteration. continue // While Loop with break and continue
int index = 0;
while (index < marks.length) {
    if (marks[index] == 87) {
        // Use 'continue' to skip printing if the element is 87
        index++;
        continue;
    }
    if (marks[index] == 105) {
        // Use 'break' to exit the loop if the element is 105
        break;
    }
    print(marks[index]);
    index++;
}

// Do-While Loop with break and continue
index = 0;
do {
    if (marks[index] == 87) {
        // Use 'continue' to skip printing if the element is 87
        index++;
        continue;
    }
    if (marks[index] == 105) {
        // Use 'break' to exit the loop if the element is 105
        break;
    }
    print(marks[index]);
    index++;
} while (index < marks.length);

// For Loop with break and continue
print("Printing marks list using for loop");
for (int i = 0; i < marks.length; i++) {
    if (marks[i] == 87) {
        // Use 'continue' to skip printing if the element is 87
        continue;
    }
    if (marks[i] == 105) {
        // Use 'break' to exit the loop if the element is 105
        break;
    }
    print(marks[i]);
} While Loop: A the loop is initialized with a condition. It iterates through the elements of the list and prints each element until the loop condition is no longer satisfied. It employs and statements to control the loop flow based on specific conditions. while marks break continue Do-While Loop: Similar to the loop, the loop executes its block of code at least once before evaluating the loop condition. It iterates through the elements of the list, employing and statements to control the loop flow based on specific conditions. while do-while marks break continue For Loop: The loop iterates over the elements of the list using an index variable. It prints each element until the loop condition is no longer satisfied. It also utilizes and statements to control the loop flow based on specific conditions. for marks break continue Conclusion Understanding Dart’s control flow structures like if-else, switch, and loops is crucial for effective programming. With break and continue statements, developers gain finer control over loop execution, enhancing code readability and maintainability. Embrace these techniques to write cleaner, more organized Dart code and unlock the full potential of Dart 3 programming. Also published here.

Exploring Dart Fundamentals — Part 2: Dart Control Flow Statement 

Welcome to the final step in creating your Collectibles portal! (for part 1, see ) here In this part, we'll focus on building the frontend—the last piece of the puzzle. Here's what we'll achieve: Connect the Flow Wallet. Initialize your account and mint your NFT. Check the NFT ID in your Collection. View the NFT with the NFT ID you have in your Collection. We will be using to build the frontend. Next.js Let's get started! 1. Installation Setting Up Open your project directory. Then, run in the terminal and press . flow-collectible-portal npx create-next-app@latest frontend enter This will provide you with several options. In this tutorial, we will not use , ESLint, or , and we will use the directory and the App router at the time of this article. Typescript TailwindCSS src Now you have a fresh web app ready. This is how your frontend folder looks: 2. Configuration To interact with the we will use the Flow Client Library (FCL) to manage wallet connections, run scripts, and send transactions in our application. It will allow us to write complete Cadence functions and run them as Javascript functions. Flow blockchain To get started, let's install FCL for our app by running the following command: npm install @onflow/fcl --save After installing FCL, we need to configure it. Here's what you need to do: Inside the folder create a new folder named and add a file named . app flow config.js In this file, set up the configuration for the FCL, such as specifying the Access Node and wallet discovery endpoint. This helps you to choose between using a testnet or a local emulator. You will also want to specify the Collectibles contract address we deployed in Part 1. Add the following code to the file: config.js import { config } from "@onflow/fcl";

config({
 "app.detail.title": "Flow Name Service",
 "app.detail.icon": "https://placekitten.com/g/200/200",
 "accessNode.api": "https://rest-testnet.onflow.org",
 "discovery.wallet": "https://fcl-discovery.onflow.org/testnet/authn",
 "0xCollectibles": "ADD YOUR CONTRACT ACCOUNT ADDRESS",
 "0xNonFungibleToken": "0x631e88ae7f1d7c20",
}); Now you're all set up to use the FCL in your app. 3. Authentication To verify a user's identity in an app, you can use several functions: For logging in, call . fcl.logIn() For signing up, call . fcl.signUp() For logging out, call . fcl.unauthenticate() Let’s learn how we can implement these functions in your frontend. fcl First, we will add the following code to our file inside the app directory. This will import some dependencies, set up some initial for parts of our app, and build a basic UI. page.js useState To make sure it looks nice, delete the file inside the app directory and instead make a file called page.css. Then paste the contents of inside of it. Now we can write out our initial page. page.module.css this file "use client";
import React, { useState, useEffect, useRef } from "react";
import * as fcl from "@onflow/fcl";
import "./page.css";
import "./flow/config";

export default function Page() {
  const [currentUser, setCurrentUser] = useState({
    loggedIn: false,
    addr: undefined,
  });

  const urlInputRef = useRef();
  const nameInputRef = useRef();
  const idInputRef = useRef();
  const [isInitialized, setIsInitialized] = useState();
  const [collectiblesList, setCollectiblesList] = useState([]);
  const [loading, setLoading] = useState(false);
  const [ids, setIds] = useState([]);
  const [nft, setNFT] = useState({});

  useEffect(() => fcl.currentUser.subscribe(setCurrentUser), []);

  function handleInputChange(event) {
    const inputValue = event.target.value;

    if (/^\d+$/.test(inputValue)) {
      idInputRef.current = +inputValue;
    } else {
      console.error("Invalid input. Please enter a valid integer.");
    }
  }

  return (
    <div>
      <div className="navbar">
        <h1>Flow Collectibles Portal</h1>
        <span>Address: {currentUser?.addr ?? "NO Address"}</span>
        <button onClick={currentUser.addr ? fcl.unauthenticate : fcl.logIn}>
          {currentUser.addr ? "Log Out" : "Connect Wallet"}
        </button>
      </div>

      {currentUser.loggedIn ? (
        <div className="main">
          <div className="mutate">
            <h1>Mutate Flow Blockchain</h1>
            <form
              onSubmit={(event) => {
                event.preventDefault();
              }}
            >
              <input
                type="text"
                placeholder="enter name of the NFT"
                ref={nameInputRef}
              />
              <input type="text" placeholder="enter a url" ref={urlInputRef} />
              <button type="submit">Mint</button>
            </form>
            <mark>Your Collection will be initialized while minting NFT.</mark>
          </div>
          <div className="query">
            <h1>Query Flow Blockchain</h1>
            <mark>Click below button to check 👇</mark>
            <button>Check Collection</button>
            <p>
              Is your collection initialized: {isInitialized ? "Yes" : "No"}
            </p>
            <button onClick={viewIds}>
              View NFT IDs you hold in your collection
            </button>
            <p>NFT Id: </p>
          </div>
          <div className="view">
            <h1>View Your NFT</h1>
            <input
              type="text"
              placeholder="enter your NFT ID"
              onChange={handleInputChange}
            />
            <button>View NFT</button>
            <div className="nft-card">
              <p>NFT id: </p>
              <p>NFT name: </p>
              <img src="" alt="" />
            </div>
          </div>
        </div>
      ) : (
        <div className="main-2">
          <h1>Connect Wallet to mint NFT!!</h1>
        </div>
      )}
    </div>
  );
} After adding this code, run to make sure everything loads correctly. npm run dev 4. Querying the Flow blockchain Before getting a deep dive into how we can use to query the Flow blockchain, add these Cadence script codes after the function in the file. fcl handleInput page.js const CHECK_COLLECTION = `
import NonFungibleToken from 0xNonFungibleToken
import Collectibles from 0xCollectibles

pub fun main(address: Address): Bool? {
    		return Collectibles.checkCollection(_addr: address)
}`

const GET_NFT_ID = `
import NonFungibleToken from 0xNonFungibleToken
import Collectibles from 0xCollectibles

pub fun main(user: Address): [UInt64] {
    	let collectionCap = 
getAccount(user).capabilities.get
<&{Collectibles.CollectionPublic}>(/public/NFTCollection) 
?? panic("This public capability does not exist.")
    	let collectionRef = collectionCap.borrow()!
    	return collectionRef.getIDs()
}
`

const GET_NFT = `
import NonFungibleToken from 0xNonFungibleToken
import Collectibles from 0xCollectibles

pub fun main(user: Address, id: UInt64): &NonFungibleToken.NFT? {
  		let collectionCap= 
getAccount(user).capabilities.get<&{Collectibles.CollectionPublic}>(/public/NFTCollection) ?? panic("This public capability does not exist.")

  	let collectionRef = collectionCap.borrow()!
return collectionRef.borrowNFT(id: id)
} With our Cadence scripts ready to go, we can now declare some Javascript functions and pass in the Cadence constants into the queries. `fcl` async function checkCollectionInit() {
    const isInit = await fcl.query({
        cadence: CHECK_COLLECTION,
        args: (arg,t) => [arg(currentUser?.addr, t.Address)],
    });
    console.log(isInit);
}

async function viewNFT() {
    console.log(idInputRef.current);
    const nfts = await fcl.query({
        	cadence: GET_NFT,
        	args: (arg,t) => [arg(currentUser?.addr,t.Address), 
arg(idInputRef.current, t.UInt64)]
    });
    setNFT(nfts);
    console.log(nfts);
}

async function viewIds() {
    const ids = await fcl.query({
        cadence: GET_NFT_ID,
        args: (arg,t) => [arg(currentUser?.addr,t.Address)]
    });
    setIds(ids);
    console.log(ids);
} Now let’s take a look at all the functions we’ve written. There are two things to notice: The fcl.query And the line. args: (arg,t) => [arg(addr,t.Address)], Since scripts are similar to functions in Solidity and don't require any gas fees to run, we are essentially just querying the blockchain. So we use to run scripts on Flow. view fcl.query To query something, we need to pass an argument. For that, we use arg, which is a function that takes a string value representing the argument, and , which is an object that contains all the different data types that Cadence has. So we can tell how to encode and decode the argument we are passing. t arg 5. Mutating the Flow blockchain While our previous functions were just “read only,” our next ones will have actions that can mutate the blockchain state and write to it; aka “mint an NFT.” To do this we’ll write another Cadence script as a constant. const MINT_NFT = `
import NonFungibleToken from 0xNonFungibleToken
import Collectibles from 0xCollectibles

transaction(name:String, image:String){
    let receiverCollectionRef: &{NonFungibleToken.CollectionPublic}
    prepare(signer:AuthAccount){
        // initialise account
        if signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath) == nil {
            let collection <- Collectibles.createEmptyCollection()
            signer.save(<-collection, to: Collectibles.CollectionStoragePath)
            let cap = signer.capabilities.storage.issue<&{Collectibles.CollectionPublic}>(Collectibles.CollectionStoragePath)
            signer.capabilities.publish( cap, at: Collectibles.CollectionPublicPath)
        }
        //takes the receiver collection refrence
        self.receiverCollectionRef = signer.borrow<&Collectibles.Collection>(from: Collectibles.CollectionStoragePath)
      ?? panic("could not borrow Collection reference")
    }
    execute{
        let nft <- Collectibles.mintNFT(name:name, image:image)
        self.receiverCollectionRef.deposit(token: <-nft)
    }
} Now add the below function after the transaction code to the file. page.js async function mint() {
	try{
	  const txnId = await fcl.mutate({
        	cadence: MINT_NFT,
        	args: (arg,t) => [arg(name,t.String), arg(image, t.String)],
	   	payer: fcl.authz,
	  	proposer: fcl.authz,
	  	authorizations: [fcl.authz],
	  	limit:999,});
	} catch(error){
	console.error('Minting failed:' error)
}
    console.log(txnId);
} As for the function, the syntax is the same as . However, we do provide several extra parameters such as the following: fcl.mutate fcl.query payer: fcl.authz,
proposer: fcl.authz,
authorizations: [fcl.authz],
limit: 50, These are Flow-specific things that define which account will be paying for the transaction (payer), broadcasting the transaction (proposer), and the accounts from which we need authorizations. (In case an account has multiple keys attached, it can behave like a multi-sig wallet.) refers to the currently connected account. fcl.authz is like gasLimit in the Ethereum world, which places an upper limit on the maximum amount of computation. If the computation crosses the limit, then the transaction will fail. limit We’ll need to add one more function that will call and handle the function we just made. mintNFT const saveCollectible = async () => {
    if (urlInputRef.current.value.length > 0 && nameInputRef.current.value.length > 0) {
      try {
        setLoading(true);
        const transaction = await mintNFT(nameInputRef.current.value, urlInputRef.current.value);
        console.log('transactionID:', transaction);
        // Handle minting success (if needed)
      } catch (error) {
        console.error('Minting failed:', error);
        // Handle minting failure (if needed)
      } finally {
        setLoading(false);
      }
    } else {
      console.log('Empty input. Try again.');
    }
  }; 6. Final code With our main functions in place, we can now plug them into our UI. However, before we do that, we’ll add some calls to help load the initial state. You can add these right above the already existing call. useEffect useEffect useEffect(() => {
    checkCollectionInit();
    viewNFT();
  }, [currentUser]);

  useEffect(() => {
    if (currentUser.loggedIn) {
      setCollectiblesList(collectiblesList);
      console.log('Setting collectibles...');
    }
  }, [currentUser]); Now back in our section with the UI, we can add our functions to the appropriate parts of the app. return return (
    <div>
      <div className="navbar">
        <h1>Flow Collectibles Portal</h1>
        <span>Address: {currentUser?.addr ?? "NO Address"}</span>
        <button onClick={currentUser.addr ? fcl.unauthenticate : fcl.logIn}>
          {currentUser.addr ? "Log Out" : "Connect Wallet"}
        </button>
      </div>

      {currentUser.loggedIn ? (
        <div className="main">
          <div className="mutate">
            <h1>Mutate Flow Blockchain</h1>
            <form
              onSubmit={(event) => {
                event.preventDefault();
                saveCollectible();
              }}
            >
              <input
                type="text"
                placeholder="enter name of the NFT"
                ref={nameInputRef}
              />
              <input type="text" placeholder="enter a url" ref={urlInputRef} />
              <button type="submit">Mint</button>
            </form>
            <mark>Your Collection will be initialized while minting NFT.</mark>
          </div>
          <div className="query">
            <h1>Query Flow Blockchain</h1>
            <mark>Click below button to check 👇</mark>
            <button onClick={checkCollectionInit}>Check Collection</button>
            <p>
              Is your collection initialized: {isInitialized ? "Yes" : "No"}
            </p>
            <button onClick={viewIds}>
              View NFT IDs you hold in your collection
            </button>
            <p>NFT Id: </p>
            {ids.map((id) => (
              <p key={id}>{id}</p>
            ))}
          </div>
          <div className="view">
            <h1>View Your NFT</h1>
            <input
              type="text"
              placeholder="enter your NFT ID"
              onChange={handleInputChange}
            />
            <button onClick={viewNFT}>View NFT</button>
            <div className="nft-card">
              <p>NFT id: {nft.id}</p>
              <p>NFT name: {nft.name}</p>
              <img src={nft.image} alt={nft.name} />
            </div>
          </div>
        </div>
      ) : (
        <div className="main-2">
          <h1>Connect Wallet to mint NFT!!</h1>
        </div>
      )}
    </div>
  ); Check the final code . here Now with the app complete, let’s walk through how to use it! First, connect your wallet by clicking the “Connect Wallet” button in the top right. Now you can mint an NFT! Enter the name of your NFT and paste in a link to the image you want to use. After you click “mint” it will prompt you to sign a transaction with your wallet. It might take a little while for the transaction to complete. After it completes, you should be able to click the bottom button to view the IDs of your NFTs. If this is your first one, then the ID should be just “1”. Now you can copy the ID of your NFT, paste it into the View section, and click “View NFT”. Conclusion Well done! You've finished part 2 of the Collectibles portal project. In summary, we focused on building the frontend of our Collectibles portal. We did this by: Creating an app with Next.js Connecting the Flow Wallet Creating our very own NFTs for minting Viewing your NFT Have a really great day! Also published here.

How to Build a Digital Collectibles Portal Using Flow and Cadence (Part 2)

কিভাবে ফ্লো এবং ক্যাডেন্স ব্যবহার করে একটি ডিজিটাল সংগ্রহযোগ্য পোর্টাল তৈরি করবেন (পর্ব 2)

So erstellen Sie ein digitales Sammlerportal mit Flow und Cadence (Teil 2)

Cómo crear un portal de coleccionables digitales utilizando flujo y cadencia (Parte 2)

Comment créer un portail d'objets de collection numériques à l'aide de Flow et de Cadence (Partie 2)

प्रवाह और ताल का उपयोग करके डिजिटल संग्रहणीय पोर्टल कैसे बनाएं (भाग 2)

フローとケイデンスを使用してデジタル グッズ ポータルを構築する方法 (パート 2)

Flow와 Cadence를 사용하여 디지털 수집품 포털을 구축하는 방법(2부)

Como construir um portal de colecionáveis digitais usando fluxo e cadência (parte 2)

Как создать портал цифровых предметов коллекционирования, используя поток и ритм (часть 2)

Akış ve Ritim Kullanılarak Dijital Koleksiyon Portalı Nasıl Oluşturulur (Bölüm 2)

Cách xây dựng cổng sưu tầm kỹ thuật số bằng cách sử dụng Flow và Cadence (Phần 2)

如何使用 Flow 和 Cadence 构建数字收藏品门户（第 2 部分）

In the latest version of Angular, we’re getting what is known as the new Control Flow syntax for our component templates. It will replace older directives for things like , , and *ngIf/else ngSwitch *ngFor In this post, we’re going to learn exactly what this change means for us and how to use it. Alright, let’s get to it. https://youtu.be/nUEERAOZKwg?embedable=true So, for those of us that are used to building things in Angular, we’re used to the structural directive , and the concept of using an for the else condition when needed. Well, we don’t need this anymore with the new Control Flow syntax. *ngIf ng-template Also, we no longer need to import the to use them. Let’s take a look at an example. CommonModule Angular Control Flow Syntax for If/Else Conditions Ok, here in our component we have this player object consisting of some data about NBA player LeBron James. app.component.ts protected player: Player = {
    name: 'LeBron James',
    games: 1421,
    points: 38652,
    fieldGoalPercentage: 0.505,
    threePointPercentage: 0.345,
    imageName: 'lebron-james'
}; If we were to imagine that, in the real world, data like this may come from an API request where it may contain data or just be undefined. We would then need to conditionally use it within our template. In this case, we want to show our player component and pass it the player data only when it’s been defined. So, we need to use an if condition. For the new syntax, it’s similar to other templating languages like PHP, razor, and others. We start with the symbol, then in parentheses, we add our condition. Here, it will be if our player value is truthy, and then we wrap whatever conditional item. In this case, it’s our player component, with a player input, and that’s it. @ app.component.html @if (player) {
    <app-player [player]="player"></app-player>
} Right now, of course, it’s showing because we have our data hard-coded. So, let’s go clear it out. protected player?: Player; And, when we save, now we can see that it’s properly removed when no data is provided. If we want to show a message when we have no data, we need to add an else statement. To do this, we just need to add another symbol, then the word "else", then a new set of curly braces where we wrap our message. @ @if (player) {
    <app-player [player]="player"></app-player>
} @else {
    <p>No player exists at this time</p>
} Then, when we save this, we see that our message is properly displayed because we now have no data. So, that’s the new syntax replacing the old . *ngIf/else Angular Control Flow Syntax for Switch Statements Next up, we have the new syntax for switch statements. We no longer need a wrapping element or in order to use an directive and each of its cases. In this example, we have a select control where we can choose Lebron, Kareem, or leave it as the default player. ng-container ngSwitch And, when we look at our data, we have three player objects, player one, LeBron, player two, Kareem, and player three, Karl Malone. protected player1: Player = {
    name: 'LeBron James',
    games: 1421,
    points: 38652,
    fieldGoalPercentage: 0.505,
    threePointPercentage: 0.345,
    imageName: 'lebron-james'
};
protected player2: Player = {
    name: 'Kareem Abdul-Jabbar',
    games: 1560,
    points: 38387,
    fieldGoalPercentage: 0.559,
    threePointPercentage: 0.056,
    imageName: 'kareem-abdul-jabbar'
};
protected player3: Player = {
    name: 'Karl Malone',
    games: 1476,
    points: 36928,
    fieldGoalPercentage: 0.516,
    threePointPercentage: 0.274,
    imageName: 'karl-malone'
}; What we want to do in the template is show the appropriate player to match the value of our form control. This control will be a value of a string matching either Lebron, Kareem, or Default. protected options = new FormControl<'LeBron' | 'Kareem' | 'Default'>('Default', { nonNullable: true }); So, back in our template, we’ll begin by adding the symbol followed by the word "switch", then in parentheses, the value that we’ll want to switch on, in this case, that will be our options control value. @ @switch (options.value) {} Now, for our first case, we add the symbol, then the word "case", followed by the value, LeBron for this case, in parentheses. Then, within curly braces, we add our player component with the player input, in this case, it will be player one because that was Lebron in our data. @ @switch (options.value) {
    @case ('LeBron') {
        <app-player [player]="player1"></app-player>
    }
} Now, we can simply copy all of this, paste it, then change the case to Kareem, and the input to player two this time for Kareem’s data. @switch (options.value) {
    @case ('LeBron') {
        <app-player [player]="player1"></app-player>
    }
    @case ('Kareem') {
        <app-player [player]="player2"></app-player>
    }
} And then, finally, we can add our default case. We’ll add the player component one last time here, and we'll pass it to player three for Karl Malone. @switch (options.value) {
    @case ('LeBron') {
        <app-player [player]="player1"></app-player>
    }
    @case ('Kareem') {
        <app-player [player]="player2"></app-player>
    }
    @default {
        <app-player [player]="player3"></app-player>
    }
} Ok, now when we save, we see Karl Malone since he was the default, and our control value is set to default when initialized. If we change to Lebron, the view is properly updated. And likewise with Kareem. So, that’s the new switch syntax; up next, we have the final example in this post, a for loop. Angular Control Flow Syntax for For Loops When adding for loops in angular, we used to need an element or for our directive. Then we would need to create a variable from a list of options, and then much of the time, we needed to add a function to help with performance. Well, it looks similar now but a little different. ng-container *ngFor trackby In this example, our list of players is larger and consists of all of these items. players.ts export const players = [
    {
        name: 'LeBron James',
        games: 1421,
        points: 38652,
        fieldGoalPercentage: 0.505,
        threePointPercentage: 0.345,
        imageName: 'lebron-james'
    },
    {
        name: 'Kareem Abdul-Jabbar',
        games: 1560,
        points: 38387,
        fieldGoalPercentage: 0.559,
        threePointPercentage: 0.056,
        imageName: 'kareem-abdul-jabbar'
    },
    {
        name: 'Karl Malone',
        games: 1476,
        points: 36928,
        fieldGoalPercentage: 0.516,
        threePointPercentage: 0.274,
        imageName: 'karl-malone'
    },
    {
        name: 'Kobe Bryant',
        games: 1346,
        points: 33643,
        fieldGoalPercentage: 0.447,
        threePointPercentage: 0.329,
        imageName: 'kobe-bryant'
    },
    {
        name: 'Michael Jordan',
        games: 1072,
        points: 32292,
        fieldGoalPercentage: 0.497,
        threePointPercentage: 0.327,
        imageName: 'michael-jordan'
    },
    {
        name: 'Dirk Nowitzki',
        games: 1522,
        points: 31560,
        fieldGoalPercentage: 0.471,
        threePointPercentage: 0.38,
        imageName: 'dirk-nowitzki'
    },
    {
        name: 'Wilt Chamberlain',
        games: 1045,
        points: 31419,
        fieldGoalPercentage: 0.54,
        threePointPercentage: 0,
        imageName: 'wilt-chamberlain'
    },
    {
        name: 'Shaquille O\'Neal',
        games: 1207,
        points: 28596,
        fieldGoalPercentage: 0.582,
        threePointPercentage: 0.045,
        imageName: 'shaquille-oneal'
    },
    {
        name: 'Carmelo Anthony',
        games: 1260,
        points: 28289,
        fieldGoalPercentage: 0.447,
        threePointPercentage: 0.355,
        imageName: 'carmelo-anthony'
    },
    {
        name: 'Moses Malone',
        games: 1329,
        points: 27409,
        fieldGoalPercentage: 0.491,
        threePointPercentage: 0.10,
        imageName: 'moses-malone'
    },
    {
        name: 'Elvin Hayes',
        games: 1303,
        points: 27313,
        fieldGoalPercentage: 0.452,
        threePointPercentage: 0.147,
        imageName: 'elvin-hayes'
    }
]; We want to list these players out in the template with a for loop. So, we start by adding the symbol again. Then, the word "for" is followed by parentheses. In these parentheses, we create our variable, we’ll call it "player." @ Then, like the old , we use the word "of", followed by our variable for our list of data, in this case, players. *ngFor @for (player of players) {
} Now, one of the key differences in the new syntax is that a track expression is mandatory. So, if we were to save this, we get an error letting us know what we’re missing. So, we need to add a semi-colon, followed by the word "track." Then we need to provide a unique value to track, something like an ID, but in our case, we’ll use the player name. @for (player of players; track player.name) {
} Ok, all that’s left now is to add our player component and pass it our player data. @for (player of players; track player.name) {
    <app-player [player]="player"></app-player>
} And now when we save, there’s our list of players. Angular For Loop Empty Template Now, what if our list was empty, and we wanted to show a message? Well, let’s clear out our list data. If we were to save right now, we'd just have a blank screen. To show a message in this case, back in our template, we can add an empty scenario for our for loop. And inside, we can add our message. @for (player of players) {
    ...
}
@empty {
    <p>There are no players to display at this time</p>
} Now, when we save, we see our message. Pretty easy, right? Angular For Loop Additional Properties Now, for those of you familiar with the old , you may be wondering about all of the old properties that we had available: *ngFor index first last even odd count Well, they all still exist in the new syntax too. We just add them much like we did before. We use the word "let" followed by the variable name we want to use, then equals and the name of the value prefixed with a dollar sign. @for (player of players;
      track player.name;
      let index = $index;
      let first = $first;
      let last = $last;
      let even = $even;
      let odd = $odd;
      let count = $count) {
    ...
} So, after adding all of these, let's say we want to display the count in a message before the first item in the list. So, we add a condition for the first item, then add a message with the string interpolated value for the list count. @if (first) {
    <strong>There are {{ count }} players in the list</strong>
} When we save, now we can see the message with the count before all items. And, let’s say we want to display the list item number next to the player name. We can do this by passing the item index to the player component. <app-player
    ...
    [index]="index"
    ...>
</app-player> Internally, this component adds one to its index value and places the string interpolated value before the name. We could also add some zebra striping by binding a class, even, to all of the even-numbered list items. <app-player
    ...
    [class.even]="even"
    ...>
</app-player> Now, we can see all of the even items are a little darker. And finally, we can highlight the first and last list items by binding a first and last class to those variables. <app-player
    ...
    [class.first]="first"
    [class.last]="last"
    ...>
</app-player> Here, we can see the first item gets a red border. And, when we scroll down to the bottom, the last item gets a blue border. Pretty straightforward, right? So, I think this is a pretty nice change. It’s pretty similar to what we’re used to but it’s a little more simple. It doesn’t require as many elements, s, and s, and it also doesn’t require any imports which is pretty nice. ng-container ng-template I guess, some things are simpler, some things are easier, and some things are just different. The Angular Control Flow Migration Schematic For those of you who may be worried about making this change to an existing codebase, don’t be. To migrate all of your existing s, s, and s, you can simply use the migration schematic which should hopefully update them without much work. *ngIf ngSwitch *ngFor ng g @angular/core:control-flow-migration Ok, so that’s pretty much all I have for Angular’s new control flow syntax. Want to See It in Action? Check out the demo code and examples of these techniques in the stackblitz example below. If you have any questions or thoughts, don’t hesitate to leave a comment. https://stackblitz.com/edit/ttnwwm?ctl=1&embed=1&file=src%2Fapp%2Fapp.component.ts&embedable=true

A Beginner-Friendly Guide On How to Use Angular's New Control Flow Syntax

How to Build a Digital Collectibles Portal Using Flow and Cadence (Part 1)

ফ্লো এবং ক্যাডেন্স ব্যবহার করে কীভাবে একটি ডিজিটাল সংগ্রহযোগ্য পোর্টাল তৈরি করবেন (পর্ব 1)

So erstellen Sie ein digitales Sammlerportal mit Flow und Cadence (Teil 1)

Cómo crear un portal de coleccionables digitales utilizando flujo y cadencia (Parte 1)

Comment créer un portail d'objets de collection numériques à l'aide de Flow et de Cadence (Partie 1)

प्रवाह और ताल का उपयोग करके डिजिटल संग्रहणीय पोर्टल कैसे बनाएं (भाग 1)

フローとケイデンスを使用してデジタル グッズ ポータルを構築する方法 (パート 1)

Flow와 Cadence를 사용하여 디지털 수집품 포털을 구축하는 방법(1부)

Como construir um portal de colecionáveis digitais usando fluxo e cadência (parte 1)

Как создать портал цифровых предметов коллекционирования, используя поток и ритм (часть 1)

Akış ve Ritim Kullanarak Dijital Koleksiyon Portalı Nasıl Oluşturulur (Bölüm 1)

Cách xây dựng cổng sưu tầm kỹ thuật số bằng cách sử dụng Flow và Cadence (Phần 1)

如何使用 Flow 和 Cadence 构建数字收藏品门户（第 1 部分）

QFLOW

qualisflow.com

-- employees

Since n.d.

COMPANY RANKING

QFLOW

EVERGREEN INDEX #8833

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

Qflow WIKI

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

QFLOW

qualisflow.com

-- employees

Since n.d.

COMPANY RANKING

QFLOW

EVERGREEN INDEX #8833

RELATED COMPANIESRANK

STORIES ABOUT QFLOW

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

Qflow WIKI

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