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

Qflow

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?

Dummy data is randomly generated data that can be substituted for live data. Whether you are a Developer, Software Engineer, or Data Scientist, sometimes you need dummy data to test what you have built, it can be a web app, mobile app, or machine learning model. If you are using python language, you can use a faker python package to create dummy data of any type, for example, dates, transactions, names, texts, time, and others. Faker is a simple python package that generates fake data with different data types. Faker package is heavily inspired by , , and by Ruby Faker. PHP Faker Perl Faker In this article, you will learn a different way to create Dummy data by using the Faker python package. Table of Contents: Faker Installation Create Faker Generator Create Names Create Dates and Times Create Personal Profile Create Sentence & Paragraph Data Create Localized Data Create the same Fake Data Reference How to Install Faker to Create Dummy Data You can install the package with pip as follows: pip install Faker From version 4.0.0, Faker dropped support for Python 2 and from version 5.0.0 it only supports Python 3.6 and above. Note: Create Faker Generator for Dummy Data To create and initialize a faker generator use the Faker() method. faker Faker

fake = Faker() from import Now you can start creating different dummy data you want. Create Names You can use the name()  method to create full fake names. _ range( ):
   print(fake.name()) for in 10 Mathew Brown Mrs. Julie Chavez Calvin Little Manuel Ponce Alyssa Jackson DVM Amy Delgado Matthew Smith Sarah Rojas Crystal Werner Tina Moore You can also use the first_name() method to create the first name and the last_name() method to create the last name. Note: Create Dates and Times If you are working with dates, faker provides different ways to create fake dates and times. In the following examples, you will learn 10 different ways to create dummy dates and times data. print(fake.date_between(start_date= ,end_date= )) print(fake.month())
print(fake.date_time())
print(fake.year())
print(fake.month_name())
print(fake.date_time_this_year())
print(fake.time())
print(fake.timezone())
print(fake.day_of_week())
print(fake.time_object()) "-3y" "-1y" # date between 2018 and 2020 2019-05-31 02 2012-05-31 17:53:01 2002 November 2021-06-30 00:34:48 08:17:51 Africa/Gaborone Thursday 17:59:37 Create a Personal Profile If you want to create fake personal and identity information you can use  the profile and simple_profile methods from the faker library. The simple_profile method creates a fake basic profile with personal information such as name, gender, mail, and address. generateProfile = Faker()

generateProfile.simple_profile() {'username': 'qfowler', 'name': 'Matthew Greene', 'sex': 'M', 'address': 'USNV Lopez\nFPO AA 45803', 'mail': 'fwest@yahoo.com', 'birthdate': datetime.date(1995, 8, 14)} The profile method creates fake personal profiles and identities such as job, company, residence,blood_group, current_location, and others. generateProfile.profile() {'job': 'Designer, television/film set', 'company': 'Murillo, Short and Townsend', 'ssn': '893-14-6729', 'residence': '6596 Daniel Spring Suite 910\nJonesborough, ID 59049', 'current_location': (Decimal('4.2622025'), Decimal('-39.109752')), 'blood_group': 'O-', 'website': ['https://hardin-johnson.org/', 'https://patterson.com/', 'https://george-snyder.info/'], 'username': 'samuelbooth', 'name': 'Shawna Spencer', 'sex': 'F', 'address': '125 Darrell Extension Suite 575\nPort Michaelbury, PA 12381', 'mail': 'nicole97@gmail.com', 'birthdate': datetime.date(1989, 11, 25)} You can also create more than one profile and save the profile data into a pandas data-frame for analysis. In the following example, we will create 1000 profiles with just 3 lines of code. pandas pd 

generateProfile = Faker() data = [generateProfile.profile() i range( )] df = pd.DataFrame(data)

print(df) import as # generate 1000 profiles for in 1000 # save profiles in pandas dataframe Let’s observe the column names of the 1000 profiles created. print(df.columns) Index(['job', 'company', 'ssn', 'residence', 'current_location', 'blood_group', 'website', 'username', 'name', 'sex', 'address', 'mail', 'birthdate'], dtype='object') We have 13 columns in the dataset. Now you can use the dummy data you generate for data analysis and visualization. Create Sentence & Paragraph Data If you are working on a software project, you can use the Faker library to generate fake text data to test some features in your web or mobile app. The Faker library provides 4 different methods to create text data as follows. (a) Create a Single Paragraph generateText = Faker()

generateText.text() 'Goal everything traditional to. Suggest stage stop international. Hold line south across new charge national.\nClose money commercial success force. Five decision even environment notice every.' (b) Create Multiple Paragraphs generateTexts = Faker()

generateTexts.texts() ['Together require growth wind picture raise. Production task tree consumer recognize personal.', 'Be six whose answer. Mr oil successful under particular option.\nStep nor once rise. Eye thank try stay only test service. Then senior within capital action. Gun already entire sign garden.', 'Painting now term direction. Will inside natural bar purpose major.\nOther hear subject do their. Institution between education would laugh example on. Real statement kid specific able foreign.'] (c) Create a Single Sentence generateSentence = Faker()

generateSentence.sentence() 'Pass front responsibility.' (d) Create Multiple Sentences generateSentences = Faker()

generateSentences.sentences() ['Maintain take star someone could kitchen employee.', 'Pay should own word begin.', 'Citizen place although old despite stay.'] Create Localized Data Faker library supports the creation of localized data. You need to pass the locale as an argument to the Faker class, by default it supports en_US locale. You can find a list of localized providers . here In the following example, we will create 10 names from China. fake_local = Faker( ) _ range( ):
    print(fake_local.name()) 'zh_CN' for in 10 李小红 赵桂香 陈小红 罗建华 宋华 刘秀芳 郭秀华 朱秀云 金艳 侯琴 You can also set multiple locales from version 3.0.0. multiple_fake = Faker([ , , ]) _ range( ):
    print(multiple_fake.city()) 'uk_UA' 'en_US' 'ja_JP' for in 10 長生郡長生村 Christieland Rileyshire 長生郡白子町 Port Curtisborough Pruittview селище Одарка хутір Богодар село Альберт 横浜市都筑区 In the above example, we created multiple cities from 3 different locations. Create the Same Fake Data To create the same fake data output, you need to seed the fake generator and then you can run the same code. myGenerator = Faker()

myGenerator.random.seed( ) i range( ):
    print(myGenerator.country()) 1234 for in 10 Slovakia (Slovak Republic) Kazakhstan Brazil Albania Bermuda United States Minor Outlying Islands Western Sahara Wallis and Futuna Sri Lanka Mozambique You can use any random number as a seed. Note: Reference Faker Github Faker Documentation If you learned something new or enjoyed reading this article, please share it so that others can see it. Until then, see you in the next post! You can also find me on Twitter . @Davis_McDavid And you can read more articles like this . here Want to keep up to date with all the latest in python? in the footer below. Subscribe to our newsletter

How to Create Dummy Data in Python 

Cómo crear datos ficticios en Python

In the previous article in this series, we looked at how we could automate deploys to Heroku using Heroku Flow for our CI/CD. That setup had two Heroku apps for staging and production but only used a single main branch. The staging app was automatically deployed when you committed to the main branch, and the production app was manually deployed by clicking the “Promote to production” button in the Heroku pipeline. That strategy assumes that you’re doing “trunk-based development,” in which you commit to a single main branch in your code repo. However, some engineering teams still follow a branching strategy called Gitflow, which involves using a dev branch and a main branch. Feature branches are merged into the dev branch to deploy code to a staging environment and on a regular cadence, the dev branch is merged into the main branch to release the code to the production environment. In this article, we’ll consider how we can configure Heroku Flow to meet our CI/CD needs when following the Gitflow branching strategy. We’ll use our Heroku Pipeline to deploy our app to our staging environment when we push to the dev branch and deploy our app to our production environment when we push it to the main branch. Ready to go with the flow? Getting Started If you’d like to follow along throughout this tutorial, you’ll need a Heroku account and a GitHub account. You can create a Heroku account here, and you can create a GitHub account here. The demo app shown in this article is deployed to Heroku, and the code is hosted on GitHub. Running Our App Locally You can run the app locally by forking the repo in GitHub, installing dependencies, and running the start command. In your terminal, do the following after forking the repo: $ cd heroku-flow-gitflow-demo
$ npm install
$ npm start After starting the app, visit http://localhost:5001/ in your browser, and you’ll see the app running locally: Creating Our Heroku Pipeline Now that we have the app running locally let’s get it deployed to Heroku so that it can be accessed anywhere, not just on your machine. We’re going to create a Heroku pipeline that includes two apps: a staging app and a production app. To create a new Heroku pipeline, navigate to your Heroku dashboard, click the “New” button in the top-right corner of the screen, and then choose “Create new pipeline” from the menu. In the dialog that appears, give your pipeline a name, choose an owner (yourself), and connect your GitHub repo. If this is your first time connecting your GitHub account to Heroku, a second popup will appear in which you can confirm giving Heroku access to GitHub. After connecting to GitHub, click “Create pipeline” to finish the process. With that, you’ve created a Heroku pipeline. Nice work! Creating Our Staging and Production Apps As we mentioned, we’ll use two environments for our app: a staging environment and a production environment. The staging environment is where code is deployed for acceptance testing and any additional QA. The production environment is where code is released to actual users. Let’s add a staging app and a production app to our pipeline. Both of these apps will be based on the same GitHub repo. To add a staging app, click the “Add app” button in the Staging section. Next, click “Create new app” to open a side panel. In the side panel, give your app a name, choose an owner (yourself), and choose a region (I left mine in the United States). Then click “Create app” to confirm your changes. Congrats, you’ve just created a staging app! Now let’s do the same thing, but this time for our production app. When you’re done configuring your production app, you should see both apps in your pipeline: Configuring Automatic Deploys We want our app to be deployed to our staging environment any time we commit to our repo’s dev branch. To do this, click the dropdown button for the staging app and choose “Configure automatic deploys” from the menu. In the dialog that appears, make sure the dev branch is targeted, and check the box to “Wait for CI to pass before deploy.” In a later step, we’ll configure Heroku CI so that we can run tests in a CI pipeline. We don’t want to deploy our app to our staging environment unless CI is passing. Now let’s do the same thing for the production app, but this time choosing to deploy our production app whenever we commit code to the main branch. Enabling Heroku CI If we’re going to require CI to pass, we had better have something configured for CI! Navigate to the “Tests” tab and then click the “Enable Heroku CI” button. Our demo app is built with Node and runs unit tests with Jest. The tests are run through the npm test script. Heroku CI allows you to configure more complicated CI setups using an app.json file, but in our case because the test setup is fairly basic, Heroku CI can figure out which command to run without any additional configuration on our part. Pretty neat! Enabling Review Apps For the last part of our pipeline setup, let’s enable review apps. Review apps are temporary apps which get deployed for every pull request (PR) created in GitHub. They’re incredibly helpful when you want your code reviewer to manually review your changes. With a review app in place, the reviewer can simply open the review app rather than having to pull down the code onto their machine to run the app locally. To enable review apps, click the “Enable Review Apps” button on the pipeline page. In the dialog that appears, check all three boxes. The first box enables review apps to be automatically created for each PR.
The second box ensures that the review app isn’t created until CI passes.
The third box sets a time limit on how long a stale review app should exist until it is destroyed. Review apps use Heroku resources just like your regular apps, so you don’t want these temporary apps sitting around unused and costing you or your company more money. When you’re done with your configuration, click “Enable Review Apps” to finalize your changes. Seeing It All in Action Alright, you made it! Let’s review what we’ve done so far. We created a Heroku pipeline.
We created a staging app and a production app for that pipeline.
We enabled automatic deploys from the dev branch to our staging app.
We enabled automatic deploys from the main branch to our production app.
We enabled Heroku CI to run tests for every PR.
We enabled the creation of Heroku review apps for every PR. Now, let’s see it all in action! Create a feature branch off of your dev branch with any code change you’d like, and then use that to create a PR in GitHub to merge that feature branch into dev. I made a very minor UI change, updating the heading text from “Heroku Flow Gitflow Demo” to “Heroku Flow Gitflow Branching”. Right after the PR is created, you’ll note that a new “check” gets created in GitHub for the Heroku CI pipeline. You can view the test output back in Heroku on your Tests tab: After the CI pipeline passes, you’ll note that another piece of info gets appended to your PR in GitHub. The review app is deployed, and GitHub shows a link to the review app. Click the “View deployment” button, and you’ll see a temporary Heroku app with your code changes. You can also find a link to the review app in your Heroku pipeline: Let’s assume that you’ve gotten a code review and that everything looks good. It’s time to merge your PR. After you’ve merged your PR, look back at the Heroku pipeline. You’ll see that Heroku automatically deployed the staging app since new code was committed to the dev branch. At this point in the software development lifecycle, there might be some final QA or acceptance testing of the app in the staging environment. Let’s assume that everything still looks good and that you’re ready to release this change to your users in production. You can create another PR to merge the dev branch into the main branch, or you can do this from your terminal by checking out the main branch and then running git merge dev and git push. Once you’ve committed these changes to the main branch, look at your Heroku pipeline again, and you’ll see that the production app was automatically deployed. And with that, your changes are now in production for all your users to see. Way to go! Conclusion If you’ve followed along this far, give yourself a pat on the back. Walking through these steps, we’ve configured everything we need for an enterprise-ready CI/CD solution for a team using the Gitflow branching strategy and multiple environments. It doesn’t matter if you prefer trunk-based development or Gitflow as your branching strategy — Heroku Flow can support either. Now not only can you host your apps on Heroku, but you can set up all of your CI/CD infrastructure on Heroku’s platform as well. In the previous article in this series, we looked at how we could automate deploys to Heroku using Heroku Flow for our CI/CD . That setup had two Heroku apps for staging and production but only used a single main branch. The staging app was automatically deployed when you committed to the main branch, and the production app was manually deployed by clicking the “Promote to production” button in the Heroku pipeline. using Heroku Flow for our CI/CD main main That strategy assumes that you’re doing “ trunk-based development ,” in which you commit to a single main branch in your code repo. trunk-based development main However, some engineering teams still follow a branching strategy called Gitflow , which involves using a dev branch and a main branch. Feature branches are merged into the dev branch to deploy code to a staging environment and on a regular cadence, the dev branch is merged into the main branch to release the code to the production environment. Gitflow dev main dev dev main In this article, we’ll consider how we can configure Heroku Flow to meet our CI/CD needs when following the Gitflow branching strategy. We’ll use our Heroku Pipeline to deploy our app to our staging environment when we push to the dev branch and deploy our app to our production environment when we push it to the main branch. Heroku Flow dev main Ready to go with the flow? Getting Started If you’d like to follow along throughout this tutorial, you’ll need a Heroku account and a GitHub account. You can create a Heroku account here , and you can create a GitHub account here . create a Heroku account here create a GitHub account here The demo app shown in this article is deployed to Heroku, and the code is hosted on GitHub . the code is hosted on GitHub Running Our App Locally You can run the app locally by forking the repo in GitHub, installing dependencies, and running the start command. In your terminal, do the following after forking the repo: $ cd heroku-flow-gitflow-demo
$ npm install
$ npm start $ cd heroku-flow-gitflow-demo
$ npm install
$ npm start After starting the app, visit http://localhost:5001/ in your browser, and you’ll see the app running locally: http://localhost:5001/ Creating Our Heroku Pipeline Now that we have the app running locally let’s get it deployed to Heroku so that it can be accessed anywhere, not just on your machine. We’re going to create a Heroku pipeline that includes two apps: a staging app and a production app. To create a new Heroku pipeline, navigate to your Heroku dashboard, click the “New” button in the top-right corner of the screen, and then choose “Create new pipeline” from the menu. In the dialog that appears, give your pipeline a name, choose an owner (yourself), and connect your GitHub repo. If this is your first time connecting your GitHub account to Heroku, a second popup will appear in which you can confirm giving Heroku access to GitHub. After connecting to GitHub, click “Create pipeline” to finish the process. With that, you’ve created a Heroku pipeline. Nice work! Creating Our Staging and Production Apps As we mentioned, we’ll use two environments for our app: a staging environment and a production environment. The staging environment is where code is deployed for acceptance testing and any additional QA. The production environment is where code is released to actual users. Let’s add a staging app and a production app to our pipeline. Both of these apps will be based on the same GitHub repo. To add a staging app, click the “Add app” button in the Staging section. Next, click “Create new app” to open a side panel. In the side panel, give your app a name, choose an owner (yourself), and choose a region (I left mine in the United States). Then click “Create app” to confirm your changes. Congrats, you’ve just created a staging app! Now let’s do the same thing, but this time for our production app. When you’re done configuring your production app, you should see both apps in your pipeline: Configuring Automatic Deploys We want our app to be deployed to our staging environment any time we commit to our repo’s dev branch. To do this, click the dropdown button for the staging app and choose “Configure automatic deploys” from the menu. dev In the dialog that appears, make sure the dev branch is targeted, and check the box to “Wait for CI to pass before deploy.” In a later step, we’ll configure Heroku CI so that we can run tests in a CI pipeline. We don’t want to deploy our app to our staging environment unless CI is passing. dev Now let’s do the same thing for the production app, but this time choosing to deploy our production app whenever we commit code to the main branch. main Enabling Heroku CI If we’re going to require CI to pass, we had better have something configured for CI! Navigate to the “Tests” tab and then click the “Enable Heroku CI” button. Our demo app is built with Node and runs unit tests with Jest. The tests are run through the npm test script. Heroku CI allows you to configure more complicated CI setups using an app.json file, but in our case because the test setup is fairly basic, Heroku CI can figure out which command to run without any additional configuration on our part. Pretty neat! npm test app.json Enabling Review Apps For the last part of our pipeline setup, let’s enable review apps. Review apps are temporary apps which get deployed for every pull request (PR) created in GitHub. They’re incredibly helpful when you want your code reviewer to manually review your changes. With a review app in place, the reviewer can simply open the review app rather than having to pull down the code onto their machine to run the app locally. To enable review apps, click the “Enable Review Apps” button on the pipeline page. In the dialog that appears, check all three boxes. The first box enables review apps to be automatically created for each PR. The second box ensures that the review app isn’t created until CI passes. The third box sets a time limit on how long a stale review app should exist until it is destroyed. Review apps use Heroku resources just like your regular apps, so you don’t want these temporary apps sitting around unused and costing you or your company more money. The first box enables review apps to be automatically created for each PR. The second box ensures that the review app isn’t created until CI passes. The third box sets a time limit on how long a stale review app should exist until it is destroyed. Review apps use Heroku resources just like your regular apps, so you don’t want these temporary apps sitting around unused and costing you or your company more money. When you’re done with your configuration, click “Enable Review Apps” to finalize your changes. Seeing It All in Action Alright, you made it! Let’s review what we’ve done so far. We created a Heroku pipeline. We created a staging app and a production app for that pipeline. We enabled automatic deploys from the dev branch to our staging app. We enabled automatic deploys from the main branch to our production app. We enabled Heroku CI to run tests for every PR. We enabled the creation of Heroku review apps for every PR. We created a Heroku pipeline. We created a staging app and a production app for that pipeline. We enabled automatic deploys from the dev branch to our staging app. dev We enabled automatic deploys from the main branch to our production app. main We enabled Heroku CI to run tests for every PR. We enabled the creation of Heroku review apps for every PR. Now, let’s see it all in action! Create a feature branch off of your dev branch with any code change you’d like, and then use that to create a PR in GitHub to merge that feature branch into dev . I made a very minor UI change, updating the heading text from “Heroku Flow Gitflow Demo” to “Heroku Flow Gitflow Branching”. dev dev Right after the PR is created, you’ll note that a new “check” gets created in GitHub for the Heroku CI pipeline. You can view the test output back in Heroku on your Tests tab: After the CI pipeline passes, you’ll note that another piece of info gets appended to your PR in GitHub. The review app is deployed, and GitHub shows a link to the review app. Click the “View deployment” button, and you’ll see a temporary Heroku app with your code changes. You can also find a link to the review app in your Heroku pipeline: Let’s assume that you’ve gotten a code review and that everything looks good. It’s time to merge your PR. After you’ve merged your PR, look back at the Heroku pipeline. You’ll see that Heroku automatically deployed the staging app since new code was committed to the dev branch. dev At this point in the software development lifecycle, there might be some final QA or acceptance testing of the app in the staging environment. Let’s assume that everything still looks good and that you’re ready to release this change to your users in production. You can create another PR to merge the dev branch into the main branch, or you can do this from your terminal by checking out the main branch and then running git merge dev and git push . dev main main git merge dev git push Once you’ve committed these changes to the main branch, look at your Heroku pipeline again, and you’ll see that the production app was automatically deployed. main And with that, your changes are now in production for all your users to see. Way to go! Conclusion If you’ve followed along this far, give yourself a pat on the back. Walking through these steps, we’ve configured everything we need for an enterprise-ready CI/CD solution for a team using the Gitflow branching strategy and multiple environments. It doesn’t matter if you prefer trunk-based development or Gitflow as your branching strategy — Heroku Flow can support either. Now not only can you host your apps on Heroku, but you can set up all of your CI/CD infrastructure on Heroku’s platform as well.

Go With the CI/CD Flow: Using Heroku Flow With Gitflow Branching

The Heroku team has long been an advocate of CI/CD. Their platform integrates with many third-party solutions like GitLab CI/CD or GitHub Actions. In a previous article, I demonstrated how you can configure your Heroku app with GitLab CI/CD to automatically deploy your app to production. In a follow-up article, I walked you through a slightly more nuanced setup involving both a staging environment and a production environment. But if you want to go all in on Heroku, you can use a series of solutions called Heroku Flow to configure all your CI/CD without any third parties. Heroku Flow brings together Heroku pipelines, Heroku CI, Heroku review apps, a GitHub integration, and a release phase. In this article, I’ll show you how to set this up for your own projects. Getting Started Before we begin, if you’d like to follow along, you’ll need a Heroku account and a GitHub account. You can create a Heroku account here, and you can create a GitHub account here. The demo app shown in this article is deployed to Heroku, and the code is hosted on GitHub. Running Our App Locally You can run the app locally by forking the repo in GitHub, installing dependencies, and running the start command. In your terminal, do the following after forking the repo: $ cd heroku-flow-demo
$ npm install
$ npm start After starting the app, visit http://localhost:5001/ in your browser, and you’ll see the app running locally: Creating Our Heroku Pipeline Now that we have the app running locally let’s get it deployed to Heroku so that it can be accessed anywhere, not just on your machine. We’ll create a Heroku pipeline that includes a staging app and a production app. To create a new Heroku pipeline, navigate to your Heroku dashboard, click the “New” button in the top-right corner of the screen, and then choose “Create new pipeline” from the menu. In the dialog that appears, give your pipeline a name, choose an owner (yourself), and connect your GitHub repo. If this is your first time connecting your GitHub account to Heroku, a second popup will appear in which you can confirm giving Heroku access to GitHub. After connecting to GitHub, click “Create pipeline” to finish the process. With that, you’ve created a Heroku pipeline. Well done! Creating Our Staging and Production Apps Most engineering organizations use at least two environments: a staging environment and a production environment. The staging environment is where code is deployed for acceptance testing and any additional QA. Code in the staging environment is then promoted to the production environment to be released to actual users. Let’s add a staging app and a production app to our pipeline. Both of these apps will be based on the same GitHub repo. To add a staging app, click the “Add app” button in the “Staging” section. Next, click “Create new app” to open a side panel. In the side panel, give your app a name, choose an owner (yourself), and choose a region (I left mine in the United States). Then click “Create app” to confirm your changes. Congrats, you’ve just created a staging app! Now, let’s do the same thing, but this time for our production app. When you’re done configuring your production app, you should see both apps in your pipeline: Configuring Automatic Deploys We want our app to be deployed to our staging environment any time we commit to our repo’s main branch. To do this, click the dropdown button for the staging app and choose “Configure automatic deploys” from the menu. In the dialog that appears, make sure the main branch is targeted, and check the box to “Wait for CI to pass before deploy.” In our next step, we’ll configure Heroku CI so that we can run tests in a CI pipeline. We don’t want to deploy our app to our staging environment unless CI is passing. Enabling Heroku CI If we’re going to require CI to pass, we better have something configured for CI! Navigate to the “Tests” tab and then click the “Enable Heroku CI” button. Our demo app is built with Node and runs unit tests with Jest. The tests are run through the npm test script. Heroku CI allows you to configure more complicated CI setups using an app.json file, but in our case, because the test setup is fairly basic, Heroku CI can figure out which command to run without any additional configuration on our part. Pretty neat! Enabling Review Apps For the last part of our pipeline setup, let’s enable review apps. Review apps are temporary apps that get deployed for every pull request (PR) created in GitHub. They’re incredibly helpful when you want your code reviewer to review your changes manually. With a review app in place, the reviewer can simply open the review app rather than having to pull down the code onto their machine and run the app locally. To enable review apps, click the “Enable Review Apps” button on the pipeline page. In the dialog that appears, check all three boxes. The first box enables the automatic creation of review apps for each PR.
The second box ensures that CI must pass before the review app can be created.
The third box sets a time limit on how long a stale review app should exist until it is destroyed. Review apps use Heroku resources just like your regular apps, so you don’t want these temporary apps sitting around unused and costing you or your company more money. When you’re done with your configuration, click “Enable Review Apps” to finalize your changes. Seeing It All in Action Alright, you made it! Let’s review what we’ve done so far. We created a Heroku pipeline.
We created a staging app and a production app for that pipeline
We enabled automatic deploys for our staging app
We enabled Heroku CI to run tests for every PR
We enabled Heroku review apps to be created for every PR Now, let’s see it all in action. Create a PR in GitHub with any code change you’d like. I made a very minor UI change, updating the heading text from “Heroku Flow Demo” to “Heroku Flow Rules!” Right after the PR is created, you’ll note that a new “check” gets created in GitHub for the Heroku CI pipeline. You can view the test output back in Heroku on your “Tests” tab: After the CI pipeline passes, you’ll note another piece of info gets appended to your PR in GitHub. The review app gets deployed, and GitHub shows a link to the review app. Click the “View deployment” button, and you’ll see a temporary Heroku app with your code changes in it. You can also find a link to the review app in your Heroku pipeline: Let’s assume that you’ve gotten a code review and that everything looks good. It’s time to merge your PR. After you’ve merged your PR, look back at the Heroku pipeline. You’ll see that the staging app was automatically deployed since new code was committed to the main branch. At this point in the software development lifecycle, there might be some final QA or acceptance testing of the app in the staging environment. Let’s assume that everything still looks good and that you’re ready to release this change to your users. Click the “Promote to production” button on the staging app. This will open a dialog for you to confirm your action. Click “Promote” to confirm your changes. After promoting the code, you’ll see the production app being deployed. And with that, your changes are now in production for all of your users to enjoy. Nice work! Conclusion What a journey we’ve been through! In this short time together, we’ve configured everything we need for an enterprise-ready CI/CD solution. If you’d like to use a different CI/CD tool like GitLab CI/CD, GitHub Actions — or whatever else you may prefer — Heroku supports that as well. But if you don’t want to reach out to a third-party CI/CD provider, you can now do it all within Heroku with Heroku Flow. The Heroku team has long been an advocate of CI/CD. Their platform integrates with many third-party solutions like GitLab CI/CD or GitHub Actions. In a previous article , I demonstrated how you can configure your Heroku app with GitLab CI/CD to automatically deploy your app to production. In a follow-up article , I walked you through a slightly more nuanced setup involving both a staging environment and a production environment. previous article follow-up article But if you want to go all in on Heroku, you can use a series of solutions called Heroku Flow to configure all your CI/CD without any third parties. Heroku Flow brings together Heroku pipelines, Heroku CI, Heroku review apps, a GitHub integration, and a release phase. configure all your CI/CD In this article, I’ll show you how to set this up for your own projects. Getting Started Before we begin, if you’d like to follow along, you’ll need a Heroku account and a GitHub account. You can create a Heroku account here , and you can create a GitHub account here . create a Heroku account here create a GitHub account here The demo app shown in this article is deployed to Heroku, and the code is hosted on GitHub . the code is hosted on GitHub Running Our App Locally You can run the app locally by forking the repo in GitHub, installing dependencies, and running the start command. In your terminal, do the following after forking the repo: $ cd heroku-flow-demo
$ npm install
$ npm start $ cd heroku-flow-demo
$ npm install
$ npm start After starting the app, visit http://localhost:5001/ in your browser, and you’ll see the app running locally: http://localhost:5001/ Creating Our Heroku Pipeline Now that we have the app running locally let’s get it deployed to Heroku so that it can be accessed anywhere, not just on your machine. We’ll create a Heroku pipeline that includes a staging app and a production app. To create a new Heroku pipeline, navigate to your Heroku dashboard, click the “New” button in the top-right corner of the screen, and then choose “Create new pipeline” from the menu. In the dialog that appears, give your pipeline a name, choose an owner (yourself), and connect your GitHub repo. If this is your first time connecting your GitHub account to Heroku, a second popup will appear in which you can confirm giving Heroku access to GitHub. After connecting to GitHub, click “Create pipeline” to finish the process. With that, you’ve created a Heroku pipeline. Well done! Creating Our Staging and Production Apps Most engineering organizations use at least two environments: a staging environment and a production environment. The staging environment is where code is deployed for acceptance testing and any additional QA. Code in the staging environment is then promoted to the production environment to be released to actual users. Let’s add a staging app and a production app to our pipeline. Both of these apps will be based on the same GitHub repo. To add a staging app, click the “Add app” button in the “Staging” section. Next, click “Create new app” to open a side panel. In the side panel, give your app a name, choose an owner (yourself), and choose a region (I left mine in the United States). Then click “Create app” to confirm your changes. Congrats, you’ve just created a staging app! Now, let’s do the same thing, but this time for our production app. When you’re done configuring your production app, you should see both apps in your pipeline: Configuring Automatic Deploys We want our app to be deployed to our staging environment any time we commit to our repo’s main branch. To do this, click the dropdown button for the staging app and choose “Configure automatic deploys” from the menu. main In the dialog that appears, make sure the main branch is targeted, and check the box to “Wait for CI to pass before deploy.” In our next step, we’ll configure Heroku CI so that we can run tests in a CI pipeline. We don’t want to deploy our app to our staging environment unless CI is passing. main Enabling Heroku CI If we’re going to require CI to pass, we better have something configured for CI! Navigate to the “Tests” tab and then click the “Enable Heroku CI” button. Our demo app is built with Node and runs unit tests with Jest. The tests are run through the npm test script. Heroku CI allows you to configure more complicated CI setups using an app.json file, but in our case, because the test setup is fairly basic, Heroku CI can figure out which command to run without any additional configuration on our part. Pretty neat! npm test app.json Enabling Review Apps For the last part of our pipeline setup, let’s enable review apps. Review apps are temporary apps that get deployed for every pull request (PR) created in GitHub. They’re incredibly helpful when you want your code reviewer to review your changes manually. With a review app in place, the reviewer can simply open the review app rather than having to pull down the code onto their machine and run the app locally. To enable review apps, click the “Enable Review Apps” button on the pipeline page. In the dialog that appears, check all three boxes. The first box enables the automatic creation of review apps for each PR. The second box ensures that CI must pass before the review app can be created. The third box sets a time limit on how long a stale review app should exist until it is destroyed. Review apps use Heroku resources just like your regular apps, so you don’t want these temporary apps sitting around unused and costing you or your company more money. The first box enables the automatic creation of review apps for each PR. The second box ensures that CI must pass before the review app can be created. The third box sets a time limit on how long a stale review app should exist until it is destroyed. Review apps use Heroku resources just like your regular apps, so you don’t want these temporary apps sitting around unused and costing you or your company more money. When you’re done with your configuration, click “Enable Review Apps” to finalize your changes. Seeing It All in Action Alright, you made it! Let’s review what we’ve done so far. We created a Heroku pipeline. We created a staging app and a production app for that pipeline We enabled automatic deploys for our staging app We enabled Heroku CI to run tests for every PR We enabled Heroku review apps to be created for every PR We created a Heroku pipeline. We created a staging app and a production app for that pipeline We enabled automatic deploys for our staging app We enabled Heroku CI to run tests for every PR We enabled Heroku review apps to be created for every PR Now, let’s see it all in action. Create a PR in GitHub with any code change you’d like. I made a very minor UI change, updating the heading text from “Heroku Flow Demo” to “Heroku Flow Rules!” Right after the PR is created, you’ll note that a new “check” gets created in GitHub for the Heroku CI pipeline. You can view the test output back in Heroku on your “Tests” tab: After the CI pipeline passes, you’ll note another piece of info gets appended to your PR in GitHub. The review app gets deployed, and GitHub shows a link to the review app. Click the “View deployment” button, and you’ll see a temporary Heroku app with your code changes in it. You can also find a link to the review app in your Heroku pipeline: Let’s assume that you’ve gotten a code review and that everything looks good. It’s time to merge your PR. After you’ve merged your PR, look back at the Heroku pipeline. You’ll see that the staging app was automatically deployed since new code was committed to the main branch. main At this point in the software development lifecycle, there might be some final QA or acceptance testing of the app in the staging environment. Let’s assume that everything still looks good and that you’re ready to release this change to your users. Click the “Promote to production” button on the staging app. This will open a dialog for you to confirm your action. Click “Promote” to confirm your changes. After promoting the code, you’ll see the production app being deployed. And with that, your changes are now in production for all of your users to enjoy. Nice work! Conclusion What a journey we’ve been through! In this short time together, we’ve configured everything we need for an enterprise-ready CI/CD solution. If you’d like to use a different CI/CD tool like GitLab CI/CD, GitHub Actions — or whatever else you may prefer — Heroku supports that as well. But if you don’t want to reach out to a third-party CI/CD provider, you can now do it all within Heroku with Heroku Flow. do it all

How I Got My CI/CD Act together With Heroku Flow

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 部分）

Authors: (1) Chenhao Shi, Shanghai Jiao Tong University; (2) Ruibang Liu, Shanghai Jiao Tong University; (3) Guoqiang Li†, Shanghai Jiao Tong University. Table of Links Abstract & Introduction Preliminaries Normalization Algorithm Evaluation Conclusion & References V. CONCLUSION In this paper, we propose an algorithm based on data flow analysis to construct a paradigm for R1CS. The correctness and equivalence of R1CS have long been challenging to study due to the diversity and flexibility of constraint construction methods. Our algorithm aims to eliminate the differences between equivalent R1CS constraint systems through a series of abstraction processes. We introduce ordering methods for internal variables and constraints in R1CS, which provide reference information for the final paradigm generation. Through experimental results, we demonstrate that our algorithm can identify equivalent R1CS resulting from constraint merging, intermediate variable selection, and variable and constraint reordering, and transform them into a unique paradigm. Therefore, R1CS plays an indispensable part in zk-SNARKS. Further work includes establishing rules for merging constraints and a more comprehensive benchmark. This requires us to conduct more in-depth research and exploration of the generation rules of R1CS to improve the algorithm. REFERENCES [1] S. Goldwasser, S. Micali, and C. Rackoff, “The knowledge complexity of interactive proof-systems,” in Providing Sound Foundations for Cryptography: On the Work of Shafi Goldwasser and Silvio Micali, 2019, pp. 203–225. [2] Zcash company, https://z.cash/, 2014. [3] E. B. Sasson, A. Chiesa, C. Garman, et al., “Zerocash: Decentralized anonymous payments from bitcoin,” in 2014 IEEE symposium on security and privacy, IEEE, 2014, pp. 459–474. [4] G. Drevon, J-r1cs – a json lines format for r1cs, 2019. [5] E. Albert, M. Belles-Mu ´ noz, M. Isabel, C. Rodrı ˜ eguez- ´ Nu´nez, and A. Rubio, “Distilling constraints in zero- ˜ knowledge protocols,” in Computer Aided Verification: 34th International Conference, CAV 2022, Haifa, Israel, August 7–10, 2022, Proceedings, Part I, Springer, 2022, pp. 430–443. [6] E. Ben-Sasson, A. Chiesa, M. Riabzev, N. Spooner, M. Virza, and N. P. Ward, “Aurora: Transparent succinct arguments for r1cs,” in Advances in Cryptology– EUROCRYPT 2019: 38th Annual International Conference on the Theory and Applications of Cryptographic Techniques, Darmstadt, Germany, May 19–23, 2019, Proceedings, Part I 38, Springer, 2019, pp. 103–128. [7] J. Lee, S. Setty, J. Thaler, and R. Wahby, “Lineartime and post-quantum zero-knowledge snarks for r1cs,” Cryptology ePrint Archive, 2021. [8] A. Golovnev, J. Lee, S. Setty, J. Thaler, and R. S. Wahby, “Brakedown: Linear-time and post-quantum snarks for r1cs,” Cryptology ePrint Archive, 2021. [9] Y. Muzi, F. Muyue, B. Gu, et al., Semantic comparison method and device between a kind of source code and binary code, 2019. [10] G. Li, L. Zhongqi, Y. Dongsheng, and Y. Liu, Compiling method from intermediate language (il) program to c language program of instruction list, 2013. [11] Z. Yongsheng, C. Zhiyong, C. Rongtao, and W. Zhili, A kind of assembly language is to the code conversion method of higher level language and device, 2015. [12] E. Ben-Sasson, A. Chiesa, E. Tromer, and M. Virza, “Succinct {non-interactive} zero knowledge for a von neumann architecture,” in 23rd USENIX Security Symposium (USENIX Security 14), 2014, pp. 781–796. [13] V. Buterin, “Quadratic arithmetic programs: From zero to hero,” URl: https://medium. com/@ VitalikButerin/quadratic-arithmetic-programs-fromzero-to-hero-f6d558cea649, 2016. [14] H. Vollmer, Introduction to circuit complexity: a uniform approach. Springer Science & Business Media, 1999. [15] J. Groth, “On the size of pairing-based non-interactive arguments,” in Advances in Cryptology–EUROCRYPT 2016: 35th Annual International Conference on the Theory and Applications of Cryptographic Techniques, Vienna, Austria, May 8-12, 2016, Proceedings, Part II 35, Springer, 2016, pp. 305–326. [16] J. B. Dennis, “First version of a data flow procedure language,” in Programming Symposium: Proceedings, Colloque sur la Programmation Paris, April 9–11, 1974, Springer, 2005, pp. 362–376. [17] P. C. Treleaven, D. R. Brownbridge, and R. P. Hopkins, “Data-driven and demand-driven computer architecture,” ACM Computing Surveys (CSUR), vol. 14, no. 1, pp. 93–143, 1982. [18] W. Xing and A. Ghorbani, “Weighted pagerank algorithm,” in Proceedings. Second Annual Conference on Communication Networks and Services Research, 2004., IEEE, 2004, pp. 305–314. [19] L. Page, S. Brin, R. Motwani, and T. Winograd, “The pagerank citation ranking: Bring order to the web,” Technical report, stanford University, Tech. Rep., 1998. This paper is under CC BY 4.0 DEED license. available on arxiv

Data-Flow-Based Normalization Generation Algorithm of R1CS: Conclusion & References

Composability in blockchains refers to a framework that permits the interaction and interconnection of discrete elements, especially smart contracts. This kind of modular ecosystem is important as it helps programmers utilize existing components to build advanced systems very quickly. In this article, we’ll look at composability — what it means, how it works on blockchain, some of its benefits and opportunities, and how it powers some of the innovations behind the Flow blockchain. What is composability? Composability is an age-old programming concept that saves developers (who are working within an ecosystem) from writing redundant code. This is achieved by abstracting out programming logic into logically independent units called functions. For example, let’s say you’re building an application that needs to provide functionality to convert USD to INR on several pages. You could either write the same logic repeatedly on different pages or define it in a function and just call that function everywhere. In essence, this concept resembles constructing a monument using LEGO bricks, where the bricks are the composable functions. Composability is like the compound interest of programming. Once someone solves a problem and publishes it in a modular way for others to use, the problem is solved for everyone.Benefits of composability Benefits of composability Composability has several benefits. Saves developer hours: If developers use pre-existing functions written by other devs, it saves them a lot of time compared to if they implemented their own logic. This could be anywhere from three lines of code to 1,000 lines. Reduces probability of errors: This happens for two reasons. If every developer implemented logic on their own, there would be an increased risk of one of them making an error. Secondly, as the same logic gets used in multiple places, it creates several testers who are incentivized to make sure the logic works. Readability: Replacing hundreds of lines of code with a logical function name definitely enhances the readability of code for future developers. Easier to make changes: If a certain flaw is found or an update in logic is necessary, it can be done in one place instead of making the change in several places. Composability in Blockchains In blockchain, composability denotes the smooth intercommunication among distinct constituents, like smart contracts and dApps, within a network. Any smart contracts you write on the blockchain can use functionalities from other smart contracts and dApps. One way blockchains like Ethereum have achieved this is via the creation of infrastructure-level composable units in the form of Ethereum Request for Comment (ERC), which are essentially proposals. These proposals, when approved by the Ethereum community, turn into smart contracts deployed and publicly available on-chain. For example, ERC-721 is a smart contract standard for creating NFTs. It’s one of the most used composable units among NFT projects in the Ethereum ecosystem. These NFT projects just import and extend functions from ERC-721 to give their contracts powerful functionality right away. Flash loans in decentralized finance (DeFi) are also a good example of composability among several platforms. To begin, you first create a set of predesignated operations on providers like Aave. Then you run transactions on different swap protocols, like MakerDAO and Uniswap. Eventually, you repay the flash loan and mint your profit. Composability in Flow blockchain is a permissionless layer-1 blockchain that was built to support the high-scale use cases of games, virtual worlds, and the digital assets that power them. It excels in high-throughput settings such as decentralized gaming and NFT markets — situations that have a large transaction volume and high user engagement. Flow The Flow blockchain was built with composability in mind every step of the way. Let’s look at how. Sharding versus multi-node architecture There are two mechanisms commonly used in blockchains to achieve scalability: sharding for layer-1 solutions and rollups for layer-2 solutions. Ethereum, for example, has been transitioning recently from its single-node architecture to sharding. However, this has its own limitations. In sharding, the state of the blockchain is split up into multiple smaller chunks and distributed across nodes. This makes it much harder to achieve composability, as a component that a smart contract might be referring to may be in a completely different shard chain. Flow solves this problem in an innovative way, while also achieving scalability, through a process called pipe-lining. In Flow, four types of nodes work together to make a transaction happen. Collection nodes collect well-formed transactions in the transaction pool to pass on to the consensus node. Consensus nodes then form and propose blocks to the blockchain. Then execution nodes actually execute the computations of a block and finally the verification nodes verify the accuracy of computations performed by the execution node. You can read more about each of these nodes here. Below is an image that shows the sequential steps. The benefit is that Flow is able to maintain a single shared state for the entire chain as it achieves scalability without breaking the state into shards. This is very powerful and ultimately maintains composability in Flow. Composable resources in Cadence In Cadence, the language used to write smart contracts on Flow, resources can be created, deployed, and moved by other resources. This is most commonly used in NFTs, where an NFT collection is defined as a resource. It then owns NFTs inside it, which are also resources. These NFTs defined inside the collection can be accessed and used by other contracts; only the access control is defined by the parent resource. The contracts can also be written in a way that is generic and can be easily extended by other contracts. Compatibility with EVM and Ethereum The Flow blockchain ecosystem has recently announced compatibility with EVM. The benefits of this are twofold: Popular Ethereum applications like Aave, MetaMask, Uniswap, and so on will be fully available out of the box on the Flow blockchain and do not need any porting. This will encourage developers to onboard the Flow blockchain. Developers can enhance their existing Solidity smart contracts using Cadence on Flow. This encourages a new level of composability across chains. You can read more about the announcement . This was launched recently. here Business opportunities enabled by composability on Flow Gaming and NFTs Games might have several assets, like player accessories and skins, which are highly desirable among gamers. More often than not, these assets are obtained by the gamer after spending a lot of time on the game. If these assets are modeled as NFTs, the concepts of composability on Flow can be utilized to make them available across games. This would mean: Increased gamer engagement: Gamers will now know their assets are valuable even if their game shuts down. This will result in better financial outcomes for all. Lower onboarding barrier: Every time a player starts a new game, they will not be starting from scratch as they already have some assets. This makes it very easy for games to acquire new players. Increased “GDP”: Composability and interoperability will create a secondary market for assets that increases the overall GDP of the gaming ecosystem. Publishing Content, like written posts, can be modeled as NFTs and used across platforms. Recently, a partnership was forged between Zora, an NFT marketplace, and Mirror, a decentralized blogging platform. This partnership allowed writers on Mirror to package their popular articles as NFTs and auction them on Zora. This resulted in increased income for these writers. Similar models are possible on the Flow blockchain. Writers can then use these funds to fuel their future projects. DeFi As previously mentioned, flash loans are constructed on the fundamentals of composability and prove very beneficial in market-making. Even normal tokens on Flow can be used across protocols and smart contracts owing to the tenets of composability. Every token carries its own identity and code that defines its behavior. So every time a token exchanges hands, all the “composable” functions come with it. Cross-chain projects As mentioned earlier, it is now very easy for Ethereum projects to launch themselves on Flow and vice versa. This requires no new programming and can be done in a very short turnaround time. This means popular projects on Ethereum can now tap the Flow ecosystem and its users. This also means that existing Flow projects will gain traction from existing Ethereum protocol users, who will now discover Flow. This is a big win-win for both ecosystems and will boost traction overall in the world of blockchain. Conclusion The Flow blockchain has powerful built-in support for composability. This empowers Flow developers to build on top of existing infrastructure without having to write it on their own again. This also has a lot of added business advantages, as composability reduces time to market and increases interoperability. It will be interesting to see how compatibility between Flow and Ethereum evolves. You can on multi-node architecture and composability to learn more. I also recommend that you get your hands dirty by going through . refer to the official docs page Flow Docs Also appears . here

Composability in Flow: Exploring Technical and Business Opportunities 

Authors: (1) Chenhao Shi, Shanghai Jiao Tong University; (2) Ruibang Liu, Shanghai Jiao Tong University; (3) Guoqiang Li†, Shanghai Jiao Tong University. Table of Links Abstract & Introduction Preliminaries Normalization Algorithm Evaluation Conclusion & References Abstract The communities of blockchains and distributed ledgers have been stirred up by the introduction of zeroknowledge proofs (ZKPs). Originally designed to solve privacy issues, ZKPs have now evolved into an effective remedy for scalability concerns and are applied in Zcash (internet money like Bitcoin). To enable ZKPs, Rank-1 Constraint Systems (R1CS) offer a verifier for bi-linear equations. To accurately and efficiently represent R1CS, several language tools like Circom, Noir, and Snarky have been proposed to automate the compilation of advanced programs into R1CS. However, due to the flexible nature of R1CS representation, there can be significant differences in the compiled R1CS forms generated from circuit language programs with the same underlying semantics. To address this issue, this paper uses a data-flow-based R1CS paradigm algorithm, which produces a standardized format for different R1CS instances with identical semantics. By using the normalized R1CS format circuits, the complexity of circuits’ verification can be reduced. In addition, this paper presents an R1CS normalization algorithm benchmark, and our experimental evaluation demonstrates the effectiveness and correctness of our methods. —Zero-knowledge proof; Rank-1 constraint systems; Data flow graph; ZKP programming; Normalization Index Terms I. INTRODUCTION (ZKPs) are increasingly recognized for their importance in modern cryptography [1], as one and more cryptographic communities seek to address some of the blockchain’s most significant challenges: privacy and scalability. It is also the essential technique in Zcash [2], [3]. From both user’s and developer’s perspectives, the heightened emphasis on information privacy and security has led to a greater appreciation for the privacy advantages offered by zero-knowledge proofs. As decentralized finance (DeFi) usage grows, zero-knowledge applications that provide scalability and privacy advantages will have more opportunities to increase industry-wide adoption. However, not all computational problems can be directly addressed using zero-knowledge proofs. Instead, we must transform the issue into the correct form of computation. The rank-1 constraint system (R1CS) describes the execution of statements written in high-level programming languages and is used by many ZKP applications, but there is no standard way of representing them [4]. Circom is a novel domain-specific language for transforming computational problems into R1CS format circuits.[5] In the specific process of a first-order zero-knowledge proof, we first convert the problem into a computational problem in Circom, then into R1CS format circuits. Zero-knowledge proofs Due to the flexible nature of R1CS representation and variation of program organizations and compiler optimization levels, there can be significant differences in the compiled R1CS forms generated from circuit language programs with the same underlying semantics, which leads to difficulties in further ZKP program analysis and verification. This paper proposes a data-flow-based algorithm for generating normalization of R1CS, enabling the conversion of different R1CS constraints into a normal form, facilitating the determination of equivalence and correctness. To achieve this, the algorithm starts by transforming an R1CS into a data flow graph structure resembling an expression tree. It then segments and abstracts the data flow graph, eliminating differences between equivalent R1CS constraints that may arise from the generation process. Finally, sorting rules are proposed to sort the constraints and variables within R1CS, ultimately resulting in a unique normal form for equivalent R1CS. Moreover, we classify and summarize the reasons and characteristics of the different equivalent R1CS generated, based on the constraint generation logic of mainstream compilers and the expressiveness of R1CS. In addition, based on the identified reasons for producing equivalent R1CS, we create a relatively complete benchmark. Our proposed algorithm, which can pass all test cases in the benchmark, demonstrates that equivalent R1CS can be converted into a unique and identical canonical form under various circumstances. This work contributes to R1CS optimization by providing a novel algorithm for generating canonical forms of equivalent R1CS constraints. Our algorithm can eliminate unnecessary redundancy and normalize representation, thus it can improve existing methods and facilitates the analysis of equivalence and correctness. Furthermore, the effectiveness and practicality of the proposed algorithm are demonstrated through our comprehensive benchmark. Eli et al. design, implement, and evaluate a zero-knowledge succinct non-interactive argument (SNARG) R1CS [6]. Historically, research investigating the factors associated with R1CS has focused on satisfiability. In paper[7], where the prover incurs finite field operations to prove the satisfiability of an n-sized R1CS instance [7]. Alexander et al. introduce Brakedown, the first built system that provides linear-time SNARKs for NP [8]. Related Work Considering Circom and R1CS format circuits as two languages before and after compilation, research on the generation of the R1CS paradigm is more akin to research on semantic consistency in the compilation. Currently, the patent applications and research papers propose ideas and solutions for generating compilation paradigms in other languages, mainly exploring data flow [9], syntax tree [10], or semantic mapping [11] aspects. These studies offer crucial insights into the fundamental information semantically identical programs entail in the compilation process. However, due to the inherent constraints embedded within the R1CS form, this paper ultimately elects to use data flow as a starting point for research. The paper is organized as follows: In the next section, a brief preliminary review of zero-knowledge proof and related tools. Section 3 provides the process of the proposed algorithm in this paper. The technical exposition in Section 4 explains in detail the logic of the critical steps and their formal description. Section 5 presents the specific categories of benchmarks and their corresponding experimental results. Lastly, Section 6 concludes the present study. Paper Organization This paper is under CC BY 4.0 DEED license. available on arxiv

Data-Flow-Based Normalization Generation Algorithm of R1CS

In today's fast-paced digital world, we're all on a mission to conquer the productivity mountain, managing an array of tasks, deadlines, and to-do lists. At the same time, finding the right tools to boost your workflow can be overwhelming and time-consuming in our already busy schedules. I've curated 16 tools, from website management and content creation to design apps, coding utilities, automation tools, and much more that will save you time. I've included direct links, descriptions, and visuals so that you can get an initial impression of each extension right away. 1. (Sponsored) OneEntry CMS OneEntry is a headless Content Management System (CMS) designed to boost your productivity for website content creation and management experience. This cloud-based solution offers a robust set of features: OneEntry provides a user-friendly interface that is easily understandable for users without any technical background. Ease of use for everyone: The interface is intuitive, providing a clear logic for user interaction and simplifying the overall process of managing applications. It makes it easy for users to input information quickly and accurately. Intuitive data entry: It supports real-time collaboration, allowing multiple users to work on the same data simultaneously. This feature promotes teamwork and ensures data consistency. Real-time collaboration: OneEntry includes robust data validation and quality checks to minimize errors and ensure that entered data meets specified criteria. This contributes to maintaining accurate and reliable datasets. Data validation: Users can create and customize data entry forms based on their needs. This flexibility enables organizations to tailor the platform to their unique data collection requirements. Customization options: OneEntry leverages cloud technology, providing secure storage for entered data. Users can access the platform from anywhere with an internet connection. Security and accessibility: https://www.youtube.com/watch?v=gt3JKXxaQRM&embedable=true 2. Hoppscotch An open-source API development web app that simplifies and accelerates API testing and development. It offers a visual interface for crafting and sending HTTP requests, aiding developers in building and debugging APIs efficiently. 3. IFTTT Stands for "If This Then That," IFTTT is an automation app that connects different apps and services to create automated workflows. Users can define triggers and actions to automate various tasks across multiple platforms, enhancing productivity and connectivity. 4. Zapier A web automation app that enables users to create automated workflows (Zaps) between various apps. It facilitates the seamless transfer of information and actions between different online tools, streamlining business processes. 5. Hypefury A social media automation app designed for scheduling and automating social media marketing activities. It helps users save time, create value, and grow their audience faster through efficient social media management. 6. Monday A work management app that assists teams in planning, tracking, and managing projects. It provides a collaborative space for teams to enhance communication and productivity, especially in project management offices. 7. Calendly A scheduling tool used to organize and automate meetings with prospects, customers, and recruits. It simplifies the scheduling process by allowing users to share their availability and enables others to book time slots accordingly. 8. StackEdit An in-browser Markdown editor that allows users to write and edit Markdown documents for blogs, publications, documentation, and so on. It offers a distraction-free writing environment, allowing you to focus on the actual writing and be more productive. 9. QuillBot An AI-powered paraphrasing tool that helps users rewrite or rephrase content. It's useful for improving the originality and diversity of written content without you taking hours to rephrase the content yourself. 10. Happy Hues A color palette inspiration website that provides aesthetically pleasing color combinations for design projects. Designers can quickly explore and choose color schemes to enhance the visual appeal of their work with just a single click. 11. Penpot An open-source design and prototyping platform that allows collaborative design work for maximum productivity and efficiency. It supports the creation of user interfaces, wireframes, and interactive prototypes. 12. Airtable A cloud-based collaboration platform that combines the features of a spreadsheet and a database. It allows users to organize and track information, making it versatile for various use cases, from project management to content planning. 13. Todoist A popular task management and organization tool. Todoist helps users create and manage tasks, set deadlines, and organize projects to enhance productivity. 14. Smartmockups A tool for creating realistic mockups of websites and apps. It simplifies the design process by allowing users to showcase their work in a visually appealing and professional manner. 15. Invoicely An online invoicing and billing platform for freelancers and small businesses. It streamlines the invoicing process, helps track expenses, and facilitates efficient financial management. 16. DevTunes FM A project of mine, an online radio designed for busy developers. It now hosts 50+ various stations, 10 different themes, a recently played list, keyboard shortcuts, custom settings, and a lot more. Writing has always been my passion, and it gives me pleasure to help and inspire people. If you have any questions, feel free to reach out! Make sure to receive the best resources, tools, productivity tips, and career growth tips I discover by subscribing to ! my newsletter Also, connect with me on , , and ! Twitter LinkedIn GitHub Also published . here

Become a Productivity Beast With These 16 Killer Work-Flow Tools

Steam, Its Generation and Use by Babcock & Wilcox Company, is part of the HackerNoon Books Series. You can jump to any chapter in this book . FLOW OF STEAM THROUGH PIPES AND ORIFICES here FLOW OF STEAM THROUGH PIPES AND ORIFICES Various formulae for the flow of steam through pipes have been advanced, all having their basis upon Bernoulli’s theorem of the flow of water through circular pipes with the proper modifications made for the variation in constants between steam and water. The loss of energy due to friction in a pipe is given by Unwin (based upon Weisbach) as where E is the energy loss in foot pounds due to the friction of W units of weight of steam passing with a velocity of v feet per second through a pipe d feet in diameter and L feet long; g represents the acceleration due to gravity (32.2) and f the coefficient of friction. Numerous values have been given for this coefficient of friction, f , which, from experiment, apparently varies with both the diameter of pipe and the velocity of the passing steam. There is no authentic data on the rate of this variation with velocity and, as in all experiments, the effect of change of velocity has seemed less than the unavoidable errors of observation, the coefficient is assumed to vary only with the size of the pipe. Unwin established a relation for this coefficient for steam at a velocity of 100 feet per second, where K is a constant experimentally determined, and d the internal diameter of the pipe in feet. If h represents the loss of head in feet, then If D represents the density of the steam or weight per cubic foot, and p the loss of pressure due to friction in pounds per square inch, then and from equations ( 38 ), ( 40 ) and ( 41 ), To convert the velocity term and to reduce to units ordinarily used, let d 1 the diameter of pipe in inches = 12 d , and w = the flow in pounds per minute; then Substituting this value and that of d in formula ( 42 ) Some of the experimental determinations for the value of K are: K	 = 	.005 for water (Unwin).
K	 = 	.005 for air (Arson).
K	 = 	.0028 for air (St. Gothard tunnel experiments).
K	 = 	.0026 for steam (Carpenter at Oriskany).
K	 = 	.0027 for steam (G. H. Babcock). The value .0027 is apparently the most nearly correct, and substituting in formula ( 43 ) gives, This formula is the most generally accepted for the flow of steam in pipes. is calculated from this formula and gives the amount of steam passing per minute that will flow through straight smooth pipes having a length of 240 diameters from various initial pressures with one pound difference between the initial and final pressures. Table 66 To apply for other lengths of pipe and pressure losses other than those assumed, let L = the length and the diameter of the pipe, both in inches; , the loss in pounds; Q, the weight under the conditions assumed in , and Q 1 , the weight for the changed conditions. this table d l the table For any length of pipe, if the weight of steam passing is the same as given in , the loss will be, the table If the pipe length is the same as assumed in but the loss is different, the quantity of steam passing per minute will be, the table For any assumed pipe length and loss of pressure, the weight will be, To get the pressure drop for lengths other than 1000 feet, multiply by lengths in feet ÷ 1000. Example: Find the weight of steam at 100 pounds initial gauge pressure, which will pass through a 6-inch pipe 720 feet long with a pressure drop of 4 pounds. Under the conditions assumed in , 293.1 pounds would flow per minute; hence, Q = 293.1, and the table may be frequently found to be of service in problems involving the flow of steam. was calculated by Mr. E. C. Sickles for a pipe 1000 feet long from formula ( ), except that from the use of a value of the constant K = .0026 instead of .0027, the constant in the formula becomes 87.45 instead of 87. Table 67 This table 45 In using , the pressures and densities to be considered, as given at the top of the right-hand portion, are the mean of the initial and final pressures and densities. Its use is as follows: Assume an allowable drop of pressure through a given length of pipe. From the value as found in the right-hand column under the column of mean pressure, as determined by the initial and final pressures, pass to the left-hand portion of along the same line until the quantity is found corresponding to the flow required. The size of the pipe at the head of this column is that which will carry the required amount of steam with the assumed pressure drop. this table the table may be used conversely to determine the pressure drop through a pipe of a given diameter delivering a specified amount of steam by passing from the known figure in the left to the column on the right headed by the pressure which is the mean of the initial and final pressures corresponding to the drop found and the actual initial pressure present. The table For a given flow of steam and diameter of pipe, the drop in pressure is proportional to the length and if discharge quantities for other lengths of pipe than 1000 feet are required, they may be found by proportion. Elbows, globe valves and a square-ended entrance to pipes all offer resistance to the passage of steam. It is customary to measure the resistance offered by such construction in terms of the diameter of the pipe. Many formulae have been advanced for computing the length of pipe in diameters equivalent to such fittings or valves which offer resistance. These formulae, however vary widely and for ordinary purposes it will be sufficiently accurate to allow for resistance at the entrance of a pipe a length equal to 60 times the diameter; for a right angle elbow, a length equal to 40 diameters, and for a globe valve a length equal to 60 diameters. The flow of steam of a higher toward a lower pressure increases as the difference in pressure increases to a point where the external pressure becomes 58 per cent of the absolute initial pressure. Below this point the flow is neither increased nor decreased by a reduction of the external pressure, even to the extent of a perfect vacuum. The lowest pressure for which this statement holds when steam is discharged into the atmosphere is 25.37 pounds. For any pressure below this figure, the atmospheric pressure, 14.7 pounds, is greater than 58 per cent of the initial pressure. , by D. K. Clark, gives the velocity of outflow at constant density, the actual velocity of outflow expanded (the atmospheric pressure being taken as 14.7 pounds absolute, and the ratio of expansion in the nozzle being 1.624), and the corresponding discharge per square inch of orifice per minute. Table 68 Napier deduced an approximate formula for the outflow of steam into the atmosphere which checks closely with the figures just given. This formula is: In some experiments made by Professor C. H. Peabody, in the flow of steam through pipes from ¼ inch to 1½ inches long and ¼ inch in diameter, with rounded entrances, the greatest difference from Napier’s formula was 3.2 per cent excess of the experimental over the calculated results. For steam flowing through an orifice from a higher to a lower pressure where the lower pressure is greater than 58 per cent of the higher, the flow per minute may be calculated from the formula: About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Babcock & Wilcox Company (2007). Steam, Its Generation and Use. Urbana, Illinois: Project Gutenberg. Retrieved https://www.gutenberg.org/cache/epub/22657/pg22657-images.html This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at , located at . www.gutenberg.org https://www.gutenberg.org/policy/license.html

FLOW OF STEAM THROUGH PIPES AND ORIFICES

Real World Assets Will Benefit From Permissionless Data Flows

Cash flow is a critical factor for success, so it’s fair to assume companies do everything they can to control it. In reality, it’s a significant pain point for most of them. They must consider using business technology to improve their management practices. Why Is Cash Flow Important to Businesses? Ultimately, every business owner’s decisions depend on cash flow. When their inflow is positive — meaning they make more than they spend — they have much more flexibility. If it’s negative, their entire company could be at risk. Cash flow is important because it determines whether people stay in business — without a consistently positive inflow, success is unlikely. Statistically, remain open for over five years. More often than not, they shut their doors because they spend more than they make for far too long. only half of all companies Although most people don’t have impressive profit margins in their first few years of business, staying in the negative for too long affects them drastically. For example, it could lead to loan application denials, late payments, service shut-offs, or immediate debt collection. Although most businesses’ finances look good on paper, the reality is often different. A at some point, whether due to poor bookkeeping, unexpected growth, or high overhead costs. Even though occasionally being in the red is a normal part of being an entrepreneur, having a budget deficit for too long is damaging. majority experience negative cash flow Business Tech Is Essential for Cash Flow Management Consistent cash flow is a significant pain point in every single industry. Each year, more than have a period where they spend substantially more than they make. Although some professionals sometimes deal with budget deficits without long-term issues, many experience more severe consequences. nine in 10 small businesses Although many business owners believe consistent cash flow is one of their most significant pain points, they don’t leverage any technological solutions. Globally, use no tools to manage it. What’s more, roughly 9% admit they don’t even know the exact amount of money they make every month. nearly 30% of companies If these people use the right technology, they could track precisely where their money goes — meaning they could improve bookkeeping, eliminate unnecessary overhead costs, and increase profit margins. Effective cash flow management requires minimal errors, fast processing and accurate analysis — all things business technology is famous for. People who want to see their company succeed should seriously consider implementing proven tools for success. Best Practices for Tech-Driven Cash Flow Management Often, leveraging the right technology leads to better business outcomes. Professionals who follow the best practices for implementing these tools can solve their monetary issues and effectively manage their cash flow. 1. Automate Processes One of the top best practices for using business technology in cash flow management involves automation. Professionals could use it in any role, from bookkeeping to middle management. Also, business tech can minimize data entry errors. For example, an artificial intelligence payroll system won’t mistake a seven for a two during data entry or accidentally add an extra zero on a check. Fewer errors result in less administrative work and more efficient processes, meaning more effective cash flow management. 2. Simplify Steps Many businesses would benefit from simplifying their payment, bookkeeping and management processes. After all, most technologies are far more efficient than people. For example, mobile apps alone can save professionals annually. Instead of visiting a bank or writing a check in person, they can use their phones from anywhere at any time. over 725 million working hours 3. Manage Inventory Excess stock wastes of space and funds, so most businesses should consider utilizing inventory management technology. They can use predictive analytics, smart cameras or monitoring software. For example, AI can monitor shelves and notify staff when something needs restocking. Managers can review the operational record to make informed decisions when ordering new shipments. Once they collect a year’s worth of data, they can identify seasonal patterns and forecast demand. 4. Monitor in Real Time Many tools offer real-time tracking capabilities. AI-powered cameras can monitor inventory as it’s purchased and restocked. This level of precision makes supporting administrative tasks like ordering and stock counting much more straightforward. Real-time monitoring is also effective in end-user applications. The Internet of Things (IoT) can track when customers pay their bills. Considering experience late payments, this level of management would be beneficial. This way, they can stay current and better identify, trace, and contact the people who still need to pay. over 50% of companies 5. Support Manual Efforts Businesses often implement technology without considering how it will fit into their current procedures. A truly effective integration is only possible if they work with their employees. Viewing tools as support can make the transition more straightforward, save time, and improve workplace morale. 6. Collect Data Another best practice for using technology in cash flow management involves data collection. After all, a detailed, accurate spreadsheet makes administrative tasks much more manageable. Businesses can collect information through AI, website trackers, IoT sensors, or third-party software providers. 7. Conduct Risk Analysis Professionals should seriously consider conducting a risk analysis for their customers. After all, many people don’t pay on time or at all. In 2023, in the United Kingdom had unpaid invoices from 2022. Moreover, nearly one-quarter of them say the payments were at least four months late. around 55% of businesses Predictive technology is ideal in these situations since it uses data to calculate potential risks. For example, AI could leverage historical behavioral information to tell if a customer will likely be late with payments. From there, owners can decide whether or not they want to do business with them. Managing Cash Flow With Business Tech More often than not, cash flow management is challenging. After all, people must consider various factors when making decisions about debts and funds. Fortunately, business technology provides a straightforward solution to many primary root problems. People who use the best practices to implement these tools effectively will likely have a more consistent positive cash flow. Whether they automate their payroll system or leverage data to determine risk, their chances of success will increase and improve operations.

Stories, News & Mentions about QFLOW

Qflow’s Stories on HackerNoon