Cadenis in the Big Data Analytics Industry

Caden

caden

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

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

Flow is a permissionless layer-1 blockchain built to support the high-scale use cases of games, virtual worlds, and the digital assets that power them. The blockchain was created by the team behind Cryptokitties, Dapper Labs, and NBA Top Shot. One core attribute that differentiates Flow from the other blockchains is its way of providing to objects within the blockchain. Fine-grained access is a new method of providing access to users that follows the principle of least privilege. This makes it highly secure and fault-resistant. Flow is one of the unique blockchains to have this, as it is built on the fundamentals of Capability-based security. fine-grained permissions But how does this help you as a developer? If you’re writing smart contracts, then you likely have to regularly define access to objects and functions within your contract. Understanding the different types of access better will help you to define access types in code more accurately. This will allow you to write highly secure and efficient smart contracts. Let’s dive in. Understanding fine-grained permissions As opposed to Role-based access control (RBAC), where permissions are defined loosely for every role and not specifically for every individual, fine-grained permissions allow developers to define permissions for objects at the lowest level. This allows permissions to be defined for every object. This also allows you to add new permissions types, such as time-expiry and geography-based permissions. Let’s understand the core principle behind fine-grained permissions. The principle of least privilege The concept of least privilege means that in a computing environment, any module (such as a process, a user, or a programmer) only has the necessary access that it needs to do its specific job. Any other unnecessary permissions for its specific job are either revoked or unavailable. For example, a programmer whose job is to create backups does not need to make user data updates, so it should only have read permissions on the database of users. This principle is the core principle behind fine-grained permissions. Capability-based Security A capability is an unforgeable token of authority. In capability-based authorization, your identity does not matter. If you’ve been sent an access token by the owner/admin that grants you the capability to access a resource and you can execute that capability, then you will have access. Hence, at runtime, the application does not check what your identity is but only that you can access the requested resource. Thus, fine-grained access can be implemented on the foundations of capability-based security. History of fine-grained access In the 1980s, operating systems would define permissions on objects as “read”, “write”, and “execute”. This was called Access Control Lists. In the 1990s, Role-based Access Control was introduced, which allowed you to create groups and assign users to groups. Then, the concepts of attribute-based access control and capability-based access control arrived, which brought fine-grained access into the picture. In the world of blockchains, however, fine-grained access is new and brought by Cadence, the language used to write Flow smart contracts. Fine-grained access in Cadence Cadence, the language used to write flow smart contracts, has built-in special keywords to allow for fine-grained permissions to resources. Below, we dive into the common keywords and the usage of these keywords to provide fine-grained access. The access keywords Flow defines certain keywords, known as access keywords, with different parameters to define the access privileges of a certain resource. Below are the four primary keywords: Pub or access(all) Using this keyword means the declaration is accessible in all scopes. However, this also means that the declaration is not updatable except when you’re updating the value at an index of an array. Pub or access(all) are the least restrictive types of access and should generally be avoided. Below is an example of using the pub keyword: pub contract Car {    pub let carBrand: String    pub let carNameByBrand: {String: String}    pub fun returnCarBrand(): String {        return self.carBrand    }}} Following the above code example, if there’s an object called CarObject of type Car, then the statement below invocation is valid. CarObject.carBrand //Equals the value of greeting in the object The values with access type pub are generally not updatable except when updating the value at a certain index of an array. CarObject.carNameByBrand = {} //Not ValidCarObject.carNameByBrand[“Porsche”] = “Carrera” //Valid access(self) access(self) means that the declaration is only visible in the current and inner scopes. For example, an access(self) field can only be accessed by the functions of the type it is a part of. When using access(self), it is common practice to define setters and getter methods to allow other objects and contracts to access this field. This keyword makes the usage very safe but also restrictive. Below is an example of using access(self): pub contract Car {    access(self) let carBrand: String    access(self) let carNameByBrand: {String: String}    pub fun returnCarBrand(): String {        return self.carBrand    }    pub fun returnCarName(_ brand: String): String? {        return self.carNameByBrand[brand]    }}} access(contract) access(contract) means that the declaration is only accessible in the scope of the contract that defines it. Hence, functions defined in other contracts under the same account or functions defined in contracts under other accounts will not be able to access it. This keyword is unique to Cadence and comes in handy when you have any contract-specific variables you don’t want to expose to other contracts. Below is an example of using the access(contract) keyword: pub contract CarContract {    pub struct Car {        access(contract) var carBrand: String    }    pub fun returnCarBrand(_brand: Car): String {        return Car.carBrand    }}} In the above example, if you have a method in a different contract that has an object of the Car struct, you cannot get the carBrand variable directly. However, you can call the returnCarBrand function to get the value of carBrand. access(account) This keyword means that the declaration is only accessible inside the entire account owned by the current smart contract. Hence, other contracts in the same account can access a variable freely. This type of access is very powerful, allowing you to keep a variable private to your account. You are also able to deploy a smart contract that needs to use the variable in the future, if needed. This way, several contracts in the same account can share information seamlessly with one another, promoting the modularity of code. Below is an example of how to use it: pub contract CarContract {    pub struct Car {        access(account) var carBrand: String    }    pub fun returnCarBrand(_brand: Car): String {        return Car.carBrand    }}} In the above example, if you have a method in a different contract that has an object of the Car struct, you can get the carBrand variable directly. Conclusion The concept of least privilege and capability-based security play a significant role in Flow's precise permissions. The access keywords provide clear definitions of variable and function access, as we have covered in this article. One of the most noteworthy features that fundamentally strengthens the security of the Flow blockchain is its fine-grained access control. Blockchain technology has long been plagued by bugs and hacks, most of which occur because of ill-conceived access controls. However, fine-grained access control provides developers with a remarkable opportunity to effortlessly and smoothly secure their smart contracts. Ultimately, this is what sets Flow apart in the world of blockchain. On the topic of fine-grained permissions, hopefully you found this in-depth exploration valuable and helpful. For more information, refer to the . Or explore the and get some hands-on experience! official documentation Flow Docs

Better Smart Contracts with Fine-Grained Permissions using Cadence

is a permissionless layer-1 blockchain built to support the high-scale use cases of games, virtual worlds, and the digital assets that power them. The blockchain was created by the team behind CryptoKitties, Dapper Labs, and NBA Top Shot. Flow One of the best features of Flow is that it supports the paradigm of resource-oriented programming. Resource-oriented is a new way of managing memory where resources are held “in-situ” by the resource owner instead of in a separate ledger. This is very relevant for managing scarce and unreplicable digital resources on the blockchain. programming In this article, I’ll do a deep dive into resource-oriented programming—and allow you to better manage your resources in your Flow smart contracts. What is resource-oriented programming? In resource-oriented programming, objects are labeled as “resources.” Resources are a collection of variables and functions that only have exactly one copy at a time. Resources provide better composability than EVM and WASM. When something is called a resource, there are very specific rules for interacting with it. The three rules that apply to resources in resource-oriented programming are as follows: Each resource exists in only one memory location - Resources cannot be duplicated. Ownership of a resource is defined by where it is stored - No central ledger that keeps track of ownership. Only the owner of the resource can access its methods. To explain this better; in the real world, if you claim to own a watch, that ownership is proven by the fact that you possess it yourself. There is no central ledger that people refer to check if you are the owner. However, in programming, when we think of ownership, we think of a mapping somewhere in a ledger of the object ID to the owner ID. For example, in the case of ERC721 smart contracts, the ownership of digital assets is stored in a ledger owned by the main smart contract. Flow changes this paradigm of ownership by storing “resources” in the memory location owned by the owner itself (see image below). This means that if you’re holding a digital asset on the Flow blockchain, it is stored in the memory location of the account that you own. This has several benefits, which we’ll talk about in the coming section. Resources in Cadence is the world’s first high-level resource-oriented programming language. , created for Facebook’s now-defunct Diem, is the only other language that is resource-oriented, but it is more low-level. Cadence Move In Cadence, resources are defined using the “resource” keyword. Within a resource, you can define the attributes of the resource, like variables and functions. This definition of a resource now becomes a type and can be used to create objects of that type.\ An example of creating a resource and creating an instance of that resource is shown below: // Declare a resource that only includes one function.    pub resource CarAsset { // A transaction can call this function to get the "Honk Honk!"        // message from the resource.        pub fun honkHorn(): String {            return "Honk Horn!"        }    } // We're going to use the built-in create function to create a new instance    // of the Car resource    pub fun createCarAsset(): @CarAsset {        return <-create CarAsset()    } Destroy function Resources in Cadence can be explicitly destroyed using the “destroy” keyword. The Move Operator (<-) To make the moves of a resource explicit, the Move operator, such as “<-” must be used when: Initializing the value of a constant or variable with a resource Moving resources to a different variable Moving resources to the argument of a function Returning it from a function Code Example of Creating a Resource in Cadence Below is an example of a Cadence script that creates a CryptoKitty collection as a resource and also stores individual Kitties as a resource. contract CryptoKitties {// Accounts store a collection in their account storage  resource KittyCollection {// Each collection has functions to// move stored resources in and out  fun withdraw(kittyId: int): CryptoKittyfun deposit(kitty: CryptoKitty)}  // The resource objects that can be stored in the collectionresource CryptoKitty {}} transaction(signer: Account) {// Removes the Kitty from signer's collection, and stores it// temporarily on the stack. let theKitty <- signer.kittyCollection.withdraw(kittyId: myKittyId) // Moves the Kitty into the receiver's accountlet receiver = getAccount(receiverAccountId)receiver.kittyCollection.deposit(kitty: <-theKitty)} In the above code, we create a KittyCollection resource that has several CryptoKitty sub-resources within it. We then do a transfer transaction to transfer a Kitty from one user account to another. Other things to keep in mind Resources must be created using the “create” keyword. At the end of a function with resources, the resources should either be moved or destroyed. Accessing a field or a function of a resource does not destroy it. When a resource is moved, the constant or variable currently holding the resource becomes invalid. To make a resource type explicit, the prefix @ must be used in type annotations. Comparison and Benefits Resource-oriented programming versus ledger-based systems A common comparison of the ownership structure in resource-oriented programming is with ledger-based ownership. In the ledger model, like in ERC721 smart contracts, every time you have to update ownership, you need to update the mapping of the ID in a shared ledger. In resource-oriented programming, resources are stored within the account of the owner itself, so transferring a digital asset only means moving the resource from the first party to the second. This does not require updating any ledgers. Resource-oriented programming is more suitable for blockchain use cases like digital assets than the traditional ledger system. Benefits of resource-oriented programming There are several benefits that resource-oriented programming brings to the table. Let’s look at some of them below. Makes capability-based security possible Resource types provide the foundation on which capability-based security can be established. Capabilities are one of the best methods to create highly secure blockchain authorization systems. This brings the utmost security to the Flow blockchain. Eliminates reentrancy attacks Reentrancy attacks are one of the most severe smart contract vulnerabilities often exploited by hackers. In a reentrancy attack, a hacker calls the withdraw function on a smart contract recursively. This way, they are able to drain the entire funds of a smart contract. Since methods within a resource cannot be accessed by anyone but the owner, there is no possibility of a reentrancy attack. Better pricing and cost management In Ethereum, the CryptoKitties contract has 2 million digital assets collectively taking up more than 100 MB of space, living rent-free on the Ethereum blockchain. In an ideal world, it should be possible to charge the owners of Kitties based on how much of this data belongs to them on-chain. In Flow, since the resource is directly stored in the account of the owner, it is clear who needs to pay the cost for that data. Conclusion Resource-oriented programming is a new and innovative programming paradigm that has been brought to the blockchain world by the Flow blockchain. It makes resource management very efficient, easy, and secure. It also helps provide a better cost-sharing model for running blockchain infrastructure. You can refer to the on Resources to learn more. I also recommend that you get your hands dirty by going through and this . official docs page Flow Docs tutorial on Resources

The Power of Resource-Oriented Programming in Flow/Cadence: A Deep Dive

When starting a new project, it’s important to make the right choices about the blockchain and smart contract language. These choices can significantly impact the overall success of your project as well as your success as a developer. web3 In this article, we'll compare three popular smart contract programming languages: Solidity: used in Ethereum and other EVM-based platforms Cadence: used in the Flow blockchain Move: used in the Sui/Aptos blockchain We'll explain the concepts and characteristics of each language in simple terms, making it easier for beginners to understand. Let’s dive in. Solidity: The Foundation of Ethereum Smart Contracts is a high-level, object-oriented language used to build smart contracts in platforms like Ethereum. Initially, Solidity aimed to be user-friendly, attracting developers by resembling JavaScript and simplifying learning. While it still values user-friendliness, its focus has shifted to enhancing security. Currently, Solidity . Solidity has quite a few security pitfalls developers need to be aware of Some Solidity features include: Solidity uses clear, explicit code with a syntax similar to JavaScript, prioritizing ease of understanding for developers. Syntax and Simplicity: Solidity emphasizes secure coding practices and highlights risky constructs like gas usage. Security Focus: The language enforces data type declarations for variables and functions. Statically Typed: Solidity supports features like inheritance, libraries, and complex user-defined types. Inheritance and Libraries: Cadence: Empowering Digital Assets on Flow is designed by Flow, a blockchain known for helping to make web3 mainstream and working with major brands like Disney and the NBA. It ensures secure, clear, and approachable smart contract development. Cadence Some Cadence features include: The language enforces strict type-checking to prevent common errors. Type Safety: **Resource-oriented Programming:**Resources are unique types that can only move between accounts. They can’t be copied or discarded. If a function fails to store a Resource obtained from an account in the function scope during development, then semantic checks will show an error. The run-time enforces the same rules in terms of allowed operations. Contract functions that don’t handle Resources properly in scope before exiting will stop. These Resource features make them perfect for representing both fungible and non-fungible tokens. Ownership is tracked according to where they are stored, and the assets can’t be duplicated or lost since the language enforces correctness. If one person wants to access another person's stored items, the first person needs a permission called a . Using Capabilities allows you to let others access your stored items remotely. There are two types of Capabilities: public and private. If someone wants to allow everyone to access their items, they can share a public Capability. For example, an account can use a public Capability to accept tokens from anyone. On the other hand, someone can give private Capabilities to certain people, allowing them to access only certain features. For example, in a project with unique digital items, the project owner might grant an "administrator Capability" that lets those users create new items. Capability-based Security: Capability Functions have predefined conditions for safer execution. Built-in Pre- and Post-Conditions: Cadence's focus on resource-oriented programming makes it ideal for managing digital assets in areas such as onchain games. Optimized for Digital Assets: To grasp the importance of these new ideas, let's take a quick look at some history. In 2018, the Dapper Labs team began working on Cadence as a new programming language. They faced challenges with Solidity because of its limitations. The main frustration in building decentralized apps came from the way contracts were accessed using addresses, making it difficult to combine contracts. Freedom from msg.sender: Composability in Web3 Now, imagine contracts as Lego building blocks. Composability in web3 means one contract can be used as a foundation for others, adding their features together. For instance, if a contract records game results on a blockchain, another contract can be built to show the best players. Another one could go even further and use past game results to predict future game odds for betting. But here's the catch: Because of how Solidity works, contracts can only talk to one another if the first contract has permission to access the second one, even if users can access both. In Solidity, who can do what is controlled by protected functions in contracts. This means contracts know and check who is trying to access their protected areas. Cadence changes how access works. Instead of using the old way where contracts need permission, it uses Capabilities. When you have a Capability, you can use it to get to a protected item such as a function or resource. This means the contract no longer has to define who's allowed access. You can only get to the protected item if you have a Capability, which you can use with "borrow()." So, the old "msg.sender" way isn't needed anymore! The effects of composability are important. When contracts don't need to know beforehand who they're interacting with, users can easily interact with multiple contracts and their functions during a transaction if they have the right permissions (Capabilities). This also allows contracts to interact with one another directly without needing special permissions or preparations. The only condition is that the calling contract must have the required Capabilities. Move: Safeguarding Digital Assets on Sui/Aptos , used in the , addresses challenges posed by established languages like Solidity. It ensures scarcity and access control for digital assets. Move Sui/Aptos blockchain Move’s features include: : Move prevents the creation or use of assets more than once, ensuring robust blockchain applications. Preventing Double-spending : Developers have precise control over ownership and associated rights. Ownership and Rights Control : In Move, a smart contract is called a module, emphasizing modularity and organization. Module Structure : Move employs static analysis to reject invalid bytecode, enhancing security. Bytecode Verifier : Move includes a standard library for common transaction scripts. Standard Library Creating Smart Contracts Let's illustrate the differences by comparing a simple smart contract that increments a value in Cadence, Solidity, and Move. Solidity Example In Solidity, creating a contract that increments a value involves defining a contract, specifying the count variable, and creating functions to manipulate it. It uses explicit syntax for variable visibility and function declarations. // SPDC-License-Identifier: MIT pragma solidity ^0.8.17; contract Counter { uint public count; // function to get the current count function get() public view returns (uint) { return count; } // function to increment count by 1 function inc() public { count += 1; } // function to decrement count by 1 function dec() public { count -=1; } } Cadence Example Cadence's approach to incrementing a value is similar but emphasizes clarity. It utilizes a resource-oriented structure and straightforward syntax, making it easier for developers to create and manage digital assets. pub contract Counter { pub var count: Int // function to increment count by 1 pub fun increment() { self.count = self.count +1 } // function to decrement count by 1 pub fun decrement() { self.count = self.count – 1 } pub fun get(): Int { return self.count } init() { self.count = 0 } } Solidity versus Cadence Syntax Differences In Solidity, the visibility keyword comes before or after variable/function names, whereas Cadence consistently follows the visibility-type-name sequence. Scalability and Upgradability Flow's network boasts higher transaction throughput than Ethereum, making Cadence more scalable. Additionally, Flow's support for contract updates enhances development. Move Example Move introduces new concepts like modules, resources, and ownership control. A Move module creates an Incrementer resource, requiring the owner's signature for operations. module incrementer_addr::increment {

 

use aptos_framework::account;

use std::signer;

       struct Incrementer has key {

                  count: u64,

       }

 

       public entry fun increment(account: &signer) acquires Incrementer {

                  let signer_address = signer::address_of(account);

                  let c_ref = &mut borrow_global_mut<Incrementer>(signer_address).count;

                  *c_ref = *c_ref +1

       }

 

       public entry fun create_incrementer(account: &signer){

            let incrementer = Incrementer {

                  count: 0

            };

            move_to(account, incrementer);

       }

} Composite Types and Turing Completeness All three languages support composite types, allowing complex types from simpler ones. All are Turing complete, meaning they can handle any computation given enough resources. Resource-Oriented versus Object-Oriented While Solidity and Move require compilation, Cadence is interpreted. Cadence and Move employ a resource-oriented approach, securing digital ownership in one location. Conclusion: Choosing the Right Programming Language When selecting a programming language like Solidity, Cadence, or Move, consider the needs of your project. Solidity is commonly used, but it might not be very easy to work with. Developers need to be careful of the security pitfalls and understand best practices. Solidity: Mainly used for digital assets, Cadence is a newer language that focuses on security, is easy to understand, and provides developers with a superior experience. Cadence: Move is , a more complex language. Rust can be more difficult to learn and understand. Move is a new language, and it doesn't have many tools, resources, or a big community. Move: based on Rust Ultimately, your choice will impact your project's success, so make an informed decision and enjoy your ! journey as a web3 developer Also published . here

Comparing Smart Contract Languages: Solidity, Cadence, and Move

Welcome to the final step in creating your Collectibles portal! of this short series focused on building the collections portal. In this part, we'll focus on building the front end—the last piece of the puzzle. Here's what we'll achieve: Part one Connect with Flow Wallet: You'll be able to link your Flow Wallet. Create NFTs (Mint): You can make your very own by confirming the transaction. NFTs View NFTs: You'll be able to see your NFTs by asking the blockchain. We will work with React.js and an existing smart contract on Flow's testnet. This smart contract is the same Collectibles contract we crafted in part 1. Here are the steps we will follow to get there: : Setting things up and getting ready to go. Installation : Getting everything in order for a smooth operation. Configuration : Making sure you're securely connected. Authentication : Asking the blockchain for information. Querying the Flow Blockchain : Preparing your account for action. Setting up the Account : Modifying the blockchain as needed. Mutating the Flow Blockchain : Keeping track of your code. Final Step Are you ready to dive into creating your Collectibles Portal's front end? Let's get started! 1. Installation First, we need to create a React app using a tool called Yarn. To do this, open your terminal and type: yarn create react-app web After pressing Enter, your computer will begin creating a new React app inside your project. When it's done, you can open your new app. This is what your React app looks like. 2. Configuration We'll use the to manage wallet connections, run scripts, and send transactions in our application. Flow Client Library (FCL) 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: Create a file named config.js in the src folder. In this file, set up the configuration for the FCL, such as specifying the Access Node and wallet discovery endpoint. This helps you choose between using a testnet or a local emulator. Add the following code to the config.js file: import { config } from "@onflow/fcl";

config({
  "accessNode.api": "https://rest-testnet.onflow.org", // Mainnet: "https://rest-mainnet.onflow.org"
  "discovery.wallet": "https://fcl-discovery.onflow.org/testnet/authn" // Mainnet: "https://fcl-discovery.onflow.org/authn"
}) 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 use . fcl.logIn() For signing up use . fcl.signUp() For logging out call . fcl.unauthenticate() After logging in, an object named is set up. This object allows you to watch for changes in user data, perform transaction signings, and more. Let's add several buttons for sign up/login and also subscribe to changes on the . When the user is updated (which will happen after authentication), we'll set the user state in our component to reflect this. To demonstrate user-authenticated sessions, we'll conditionally render a component based on whether the user is or is not logged in. Your code should look like this: fcl.currentUser currentUser import React from "react";
import './styles/App.css';
import "./config";
import * as fcl from "@onflow/fcl";

const App = () => {

  const [user, setUser] = useState({loggedIn: null})

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

  const AuthedState = () => {
    return (
      <div>
        <div className="sub-text">Wallet Address: {user?.addr ?? "No Address"}</div>
        <button className="cta-button connect-wallet-button" onClick={fcl.unauthenticate}>
          Log Out
        </button>
      </div>
    )
  }

const UnauthenticatedState = () => {
    return (
        <button className="cta-button connect-wallet-button" onClick={fcl.logIn}>
          Log In
        </button>
    )
  }
  return (
    <div className="App">
      <div className="container">
        <div className="header-container">
          <p className="header gradient-text">Flow Collectibles Portal</p>
          <p className="sub-text">Upload your favorite collectibles to the Flow Blockchain</p>
          {user.loggedIn ? <AuthedState /> : <UnauthenticatedState />}
        </div>
      </div>
    </div>
  );
};

export default App; Now, you can either log in or sign up as a user and then log out. When you log in or sign up, a small window will pop up. In that window, you can pick a wallet provider. For this instance, let's pick the Blocto wallet to make an account. After you successfully prove it's you, you will see your wallet address on the screen like this: 4. Querying the Flow Blockchain When you're , a key task is to retrieve data from the blockchain and the smart contracts it holds. Let's understand how we can query a contract to find out about a specific NFT. Here's a simplified breakdown of the steps involved: building a dapp Import Contracts: First, you need to import the relevant contracts used in your dapp. In this example, we're interested in querying the NFTs, so we're importing the NonFungibleToken and Collectibles contracts. Use FCL: You create a function called queryNFT, which is asynchronous. Inside this function, you use the fcl.query function to query the blockchain. Set the result of the script to the app state in React so we can display the NFT in our browser. Display: Display "No NFT" if nothing was found. Take a look at the new code. We'll explain each new piece as we go. const [user, setUser] = useState({loggedIn: null})
const [nft, setNFT] = useState() //NEW

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

  // NEW
  const queryNFT = async () => {
    const nft = await fcl.query({
      cadence: `
        import NonFungibleToken from 0x631e88ae7f1d7c20
        import Collectibles from 0x490b5c865c43d0fd

        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)
        }
      `,
      args: (arg, t) => [arg(user.addr, t.Address)]
    })

    setNFT(nft ?? 'No NFT')
  }

const AuthedState = () => {
    return (
      <div>
        <div className="sub-text">Wallet Address: {user?.addr ?? "No Address"}</div>
        <div className="sub-text">NFT: {nft ?? "--"}</div>
       <button className="cta-button" onClick={queryNFT}>View NFT</button>
       <button className="cta-button connect-wallet-button" onClick={fcl.unauthenticate}>
          Log Out
        </button>
      </div>
    )
  } A few things happened. In our AuthedState component, we added a button to send a query to view the NFT and a div to display the result above it. You can see the corresponding useState initialization at the top of the component. We also built out the actual query inside of the queryNFT method. Let's take a look at it more closely. await fcl.query({
      cadence: `
        import NonFungibleToken from 0x631e88ae7f1d7c20
        import Collectibles from 0x490b5c865c43d0fd

        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)
        }
      `,
      args: (arg, t) => [arg(user.addr, t.Address)]
    }) Inside the query, you'll see we set two things: cadence and args. Remember that the Cadence code is specific to Flow's smart contract language, and you don't need to dive too deep into it unless you're working on writing more complex smart contracts. The key takeaway is that you're querying the blockchain to get NFT information based on the user's account address and the NFT ID. When you click the "View NFT" button, you'll see the NFT details, or if the NFT doesn't exist, it will display "No NFT". 5. Setting up the Account We use a process called "collection initialization” to set up a Collection resource in the user’s account. (We covered what a resource is in Part 1. You can review that here.) To make this happen, we’ll add a new function called "initAccount.” We'll use a code that asks, "Hey, does this account already have a Collection? If not, let's create one." We use something called a "transaction" to do this. Think of a transaction as a special task we want the system to do for us. Now, let's talk about how we write this code. Instead of saying "query," we use the word "mutate" for transactions. Since doing this task has a cost, we need to provide some information to Flow. We tell Flow who is suggesting the task, who is approving it, who is paying for it, and how much they're willing to pay. These parts are called "proposer," "authorizer," "payer," and "limit." Let's take a look at what the function to set up an account looks like. const initAccount = async () => {
  const transactionId = await fcl.mutate({
    cadence: `
    import Collectibles from 0x490b5c865c43d0fd

    transaction {
    prepare(signer: AuthAccount) {
        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)
        }
    }
    `,
    payer: fcl.authz,
    proposer: fcl.authz,
    authorizations: [fcl.authz],
    limit: 50
  })

  const transaction = await fcl.tx(transactionId).onceSealed()
  console.log(transaction)
} You can see the new fields we talked about. You'll also notice , which is shorthand for "use the current user to authorize this transaction.” You could also write it as . fcl.authz fcl.currentUser.authorization For this example, we'll keep it simple with the user being each of these roles. You'll also notice we are awaiting a response with our transaction data by using the syntax . This will return when the blockchain has sealed the transaction and it's complete in processing and verifying it. Now, your App.js file should look like this. (we also added a button for calling the function in the ): fcl.tx(transactionId).onceSealed() initAccount AuthedState const App = () => {

  const [user, setUser] = useState({loggedIn: null})
  const [nft, setNFT] = useState() //NEW
  const [txnStatus, setTxnStatus] = useState(null)

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

  // NEW
  const queryNFT = async () => {
    const nft = await fcl.query({
      cadence: `
        import NonFungibleToken from 0x631e88ae7f1d7c20
        import Collectibles from 0x490b5c865c43d0fd

        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)
        }
      `,
      args: (arg, t) => [arg(user.addr, t.Address)]
    })

    setNFT(nft ?? 'No NFT')
  }

  // NEW
  const initAccount = async () => {
  const transactionId = await fcl.mutate({
    cadence: `
    import Collectibles from 0x490b5c865c43d0fd

    transaction {
    prepare(signer: AuthAccount) {
        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)
        }
    }
    `,
    payer: fcl.authz,
    proposer: fcl.authz,
    authorizations: [fcl.authz],
    limit: 50
  })

  const transaction = await fcl.tx(transactionId).onceSealed()
  console.log(transaction)
}

  const mintNFT = async () => {
  const transactionId = await fcl.mutate({
    cadence: `
      import Profile from 0xProfile

      transaction(name:String, image:String){
        let receiverCollectionRef: &{NonFungibleToken.CollectionPublic}
        prepare(signer:AuthAccount){
          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)
        }
      }
    `,
    args: (arg, t) => [arg("Pikachu", t.String),arg("https://cdn.pixabay.com/photo/2020/08/29/16/08/pikachu-5527377_640.jpg",t.String)],
    payer: fcl.authz,
    proposer: fcl.authz,
    authorizations: [fcl.authz],
    limit: 50
  })

  fcl.tx(transactionId).subscribe(res => setTxnStatus(res.status))
}


    const AuthedState = () => {
    return (
      <div>
        <div className="sub-text">Wallet Address: {user?.addr ?? "No Address"}</div>
        <div className="sub-text">NFT: {nft ?? "--"}</div>
        <div className="sub-text">Transaction Status: {txnStatus ?? "--"}</div>
        <button className="cta-button" onClick={queryNFT}>View NFT</button>
        {/*NEW*/}
        <button className="cta-button" onClick={initAccount}>Create Collection</button>
        <button className="cta-button" onClick={mintNFT}>Mint</button>
        <button className="cta-button connect-wallet-button" onClick={fcl.unauthenticate}>
          Log Out
        </button>
      </div>
    )
  }


  const UnauthenticatedState = () => {
    return (
        <button className="cta-button connect-wallet-button" onClick={fcl.logIn}>
          Log In
        </button>
    )
  }

  return (
    <div className="App">
      <div className="container">
        <div className="header-container">
          <p className="header gradient-text">Flow Collectibles Portal</p>
          <p className="sub-text">Upload your favorite collectibles to the Flow Blockchain</p>
          {user.loggedIn ? <AuthedState /> : <UnauthenticatedState />}
        </div>
      </div>
    </div>
  );
};

export default App; Click the "Init Account" button. This will prompt your wallet to ask for permission to complete a transaction. Once you give permission, you'll notice a message about the transaction in the console. (Make sure the console is open.) This might take a short while. Once the message shows the result of the transaction, you can use the transactionId to find out more details about the transaction using a . block explorer 6. Mutating the Flow Blockchain After initializing the account and setting up the collection resource into it, we now and store it in the collection. To do this, we will write another transaction that allows us to mint the NFT. Everything else looks the same in the following code except for one thing: We'll subscribe to the status changes instead of waiting for them to be sealed after the mutate function returns. It looks like this: mint the NFT const executeTransaction = async () => {
const transactionId = await fcl.mutate({
    cadence: `
      import NonFungibleToken from 0x631e88ae7f1d7c20
      import Collectibles from 0x490b5c865c43d0fd

      transaction(name:String, image:String){
        let receiverCollectionRef: &{NonFungibleToken.CollectionPublic}
        prepare(signer:AuthAccount){
          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)
        }
      }
    `,
    args: (arg, t) => [arg("Pikachu", t.String),arg("https://cdn.pixabay.com/photo/2020/08/29/16/08/pikachu-5527377_640.jpg",t.String)],
    payer: fcl.authz,
    proposer: fcl.authz,
    authorizations: [fcl.authz],
    limit: 50
  })

  fcl.tx(transactionId).subscribe(res => setTransactionStatus(res.status))
} Here you can see our two arguments which are "Pikachu” and image URL “ ”. At the bottom, we've called the subscribe method instead of onceSealed. Let's see how that works inside our whole app.js file. Let’s also set the status to our React component's state so we can see what state we're in on screen. https://cdn.pixabay.com/photo/2020/08/29/16/08/pikachu-5527377_640.jpg Conclusion Well done! You've finished part 2 of the Collectibles portal project. In summary, we focused on building the front end of our Collectibles portal. We did this by: Creating an app with React.js Connecting with Flow Wallet Creating our very own NFTs for minting Viewing NFTs by asking the blockchain Now you have a better understanding. Keep up the fantastic effort! Have a really great day! Also published . here

Build an NFT Website Using The Flow Blockchain and Cadence [Part 2]

Build an NFT Website Using The Flow Blockchain and Cadence [Part 1]

Throughout this article series, we’ve its , and some of the most , all while comparing and contrasting to Ethereum. introduced you to the Flow blockchain, smart contract language Cadence essential tools developers should know In this article, we will talk about best practices and patterns that should be followed when using the Cadence language and developing solutions on the Flow network, as well as patterns to avoid. Best practices Use Flow Test Network and Flow Emulator One of the most important steps in developing on any blockchain is testing your projects in a simulated environment. Flow blockchain is no different. For this purpose, the and are both crucial components to include in your development process. Not only do they allow you to understand how your dapp will perform, but they will also help you catch any critical bugs before deploying to mainnet. Flow testnet Flow Emulator Use Standard Contracts Two of the most common use cases for any blockchain are digital currencies and providing proof of digital ownership through NFTs. Instead of trying to rewrite the necessary contracts from scratch, Flow developers should always import the official core contracts to ensure user safety and consistency with the rest of the network. There are currently three standard contracts you should use: — Used to create new tokens Fungible Token — Used to create NFTs Non-Fungible Token — Used as a metadata pattern for NFTs Metadata Views These contracts are essentially interfaces that force whoever is implementing them to add their variable and method declarations, enabling them to be interoperable with other smart contracts in the Flow ecosystem. They already exist on both testnet and mainnet networks, so be sure to import from the official addresses linked above when implementing them in your contract. You can find other core contracts . in the Flow documentation Create Tests for Your Smart Contracts, Transactions, and Scripts The is crucial for testing deployment scenarios for your contracts. However, it’s important to note that you’ll need the running in the background for full functionality. With these, you can test creating new accounts, sending transactions, running queries, executing scripts, and more. Additionally, it integrates with the Flow Emulator so you can create, run, and stop emulator instances. Flow JavaScript Testing Framework Flow CLI Add Your Contract to the Flow NFT Catalog The exists as a database to store NFT contracts and metadata. By uploading your contract, your NFTs become interoperable with the rest of the Flow ecosystem, and other developers can easily support your collection in their marketplaces or other dapps. Flow NFT Catalog You can by completing a simple four-step process. add your contract to the catalog Be Specific With Types Cadence is a and typed language that allows the developer to specify which types contain or return variables, interfaces, and functions. Therefore, you should be as specific as possible when making declarations; use generic types only in necessary situations. Not doing so can result in clumsy errors. strong statically Access Control Whenever possible, you should be deliberate with access control. Luckily, on the Flow blockchain, a caller cannot access objects in another user’s account storage without a reference to it. This is called reference-based security, and it means that nothing is truly public by default. However, when writing Cadence code, care must be taken when declaring variables, structs, functions, resources, and so on. There are four levels of access control a developer can include in their declarations: — accessible/visible in all scopes pub/access(all) — only accessible in the entire account where it’s defined (other contracts in the same account can access) access(account) — only accessible in the scope of the contract in which it is defined (cannot be accessed outside of the contract) access(contract) — only accessible in current and inner scopes priv/access(self) Avoid using pub/access(all) whenever possible. Check out the Flow documentation for . more information on access control Create StoragePath and PublicPath Constants Inside Your Contract The paths to your contract’s resources are extremely important and must be consistent across all transactions and scripts. To ensure uniformity, you should create constants for both PublicPath and StoragePath. pub contract BestPractices {
	pub let CollectionStoragePath: StoragePath
	pub let CollectionPublicPath: PublicPath

	init(){
		self.CollectionStoragePath = /storage/bestPracticesCollection
		self.CollectionPublicPath = /public/bestPracticesCollection
	}
} When you create a transaction that uses one of these paths, you only need to call its respective variable with the imported contract to reference the required path. //This script checks if a user has the public Collection from BestPractices contract
import BestPractices from 0x...

pub fun main(addr: Address): Bool {
	return getAccount(addr).getLinkTarget(BestPractices.CollectionPublicPath) != nil
} Admin Resource It’s good practice to create an administrative resource that contains specific functions to perform actions under the contract, such as a mint function. This convention ensures that only accounts with that resource or capability can perform administrative functions. pub contract BestPractices {
	pub let CollectionStoragePath: StoragePath
	pub let CollectionPublicPath: PublicPath
	pub let AdminStoragePath: StoragePath

	pub resource AdminResource {
		pub fun mintNFT(){
			//your mint NFT code here! 
		}
	}

	init(){
		self.CollectionStoragePath = /storage/bestPracticesCollection
		self.CollectionPublicPath = /public/bestPracticesCollection
		self.AdminStoragePath = /storage/bestPracticesAdmin
		
		//Create the adminResource and store it inside Contract Deployer account
		let adminResource <- create AdminResource()
		self.account.save(<- adminResource, to: self.AdminStoragePath)
	}
} Create Custom Events Events are values that can be emitted during the execution of your Cadence code. For example, when defining important actions in your contracts, you can emit events to signal their completion or deliver a specific value. As a result, transactions that interact with your smart contracts can receive additional information through these events. pub contract BestPractices {
	pub let CollectionStoragePath: StoragePath
	pub let CollectionPublicPath: PublicPath
	pub let AdminStoragePath: StoragePath

//Create your own events
pub event AdminCreated()
	

	pub resource AdminResource {
		pub fun mintNFT(){
			//your mint NFT code here! 
		}
	}

	init(){
		self.CollectionStoragePath = /storage/bestPracticesCollection
		self.CollectionPublicPath = /public/bestPracticesCollection
		self.AdminStoragePath = /storage/bestPracticesAdmin
		
		//Create the adminResource and store it inside Contract Deployer account
		let adminResource <- create AdminResource()
		self.account.save(<- adminResource, to: self.AdminStoragePath)
	}
} Patterns on Cadence/Flow Blockchain Be Specific With Types in Type Constraints One of the most powerful features of the Cadence language is undoubtedly . Through capabilities, the scope of resource access expands. capabilities An important point when creating a capability is to specify which features of your resource should be available to others. This can be done at the time of link creation using type constraints. In this example, we use the to create a basic functionality where any account that wants to receive an ExampleNFT must have a collection. ExampleNFT contract import NonFungibleToken from 0x...
import ExampleNFT from 0x...

transaction{
	prepare(acct: AuthAccount){
		let collection <- ExampleNFT.createEmptyCollection()
    // Put the new collection in storage
	  acct.save(<-collection, to: ExampleNFT.CollectionStoragePath)
    // Create a public Capability for the collection
    acct.link<&ExampleNFT.Collection{ExampleNFT.CollectionPublic}>(ExampleNFT.CollectionPublicPath, target: ExampleNFT.CollectionStoragePath)
	}
} The & symbol in specifies that we are using a . After the reference symbol, we add the type to which the capability we are creating will have access. At this point, we need to be as specific as possible. &ExampleNFT reference This pattern strengthens security and limits the functionality that the user calling the function of this capability can use. borrow Omitting the type will give you access to all the functions that exist in the reference, including the withdraw function, so that anyone can access the user's collection and steal their NFTs. {ExampleNFT.CollectionPublic} ExampleNFT.Collection Use the Borrow Function To use the resource’s features, you could call the function to remove the resource from the account, use its features, and call the function to save it again. However, this approach is costly and inefficient. Load Save To avoid this, use the function instead. It allows you to use a reference to the resource you are calling. This method makes your transaction much more efficient and cost-effective. borrow Use the check and getLinkTarget Functions When building applications on the Flow blockchain, you will discover the user’s account plays a vital role. Unlike other blockchains, such as Ethereum, Flow stores resources, assets, and more directly in the user’s account rather than as a reference to an address on a public digital ledger. This approach requires the account to have a specific storage location, such as a collection or vault for fungible tokens. However, this also adds complexity. One must be sure that the user either does or does not have the collection in their account. Both the function (which checks whether a capability exists in a given path) and the function (which returns the path of a given capability) must be used when adding collections and capabilities to the user account. These functions ensure that the transaction executes without problems. check() getLinkTarget() Use Panic Panic is a built-in function in Cadence that allows you to terminate a program unconditionally. This can occur during the execution of your smart contract code and returns an error message, which makes it easier to understand when something does not go as expected. When declaring variables, it is possible to define them as optional; meaning, if they are not of the specified type, they have a value of nil. Thus, in Cadence, it is possible to use two question marks followed by the function when querying the value of a particular variable or function that returns an optional. panic("treatment message") let optionalAccount: AuthAccount? = //...
let account = optionalAccount ?? panic("missing account") This command attempts to return the value with the specified type. If the returned value is the wrong type, or nil, the execution aborts, and the selected treatment message displays on the console. ??panic("treatment message") Anti-Patterns Although Cadence is designed to avoid many of the potential bugs and exploits found in other blockchain ecosystems, there are some anti-patterns developers should be aware of while building. Listed below are a few important ones to consider. For a complete list of anti-patterns, . check out the Flow documentation Failing to Specify the Type When Using the Borrow Function Developers should use the borrow function mentioned above to take advantage of the features available in a capability. However, it should be clear that users can store anything in their memory. Therefore, it is vital to make sure that what is borrowed is of the correct type. Not specifying the type is an anti-pattern that can end up causing errors or even breakage in your transaction and application. //Bad Practice. Should be avoided
let collection = getAccount(address).getCapability(ExampleNFT.CollectionPublicPath)
                    .borrow<&ExampleNFT.Collection>()?? panic("Could not borrow a reference to the nft collection")

//Correct! 
let collection = getAccount(address).getCapability(ExampleNFT.CollectionPublicPath)
                    .borrow<&ExampleNFT.Collection{NonFungibleToken.CollectionPublic}>()
                    ?? panic("Could not borrow a reference to the nft collection") Using AuthAccount as a Function Parameter For a transaction in the preparation phase, it is possible to access the AuthAccount field of the user. This object allows access to the memory storage and all other private areas of the account for the user who provides it. Passing this field as an argument is not recommended and should be avoided, as cases where this method is necessary are extremely rare. //Bad Practice. Should be avoided

transaction() {
	prepare(acct: AuthAccount){
		//You take sensitive and important user data out of the scope of the transaction prepare phase
		ExampleNFT.function(acct: acct)
	}
} Using Public Access Control on Dictionaries and Arrays By storing dictionaries and array variables in your contract with scope, your smart contract becomes vulnerable, as anyone can manipulate and change these values. pub/access(all) Creating Capabilities and References Using the Auth Keyword Creating capabilities and references with the keyword exposes the value to downcasting, which could provide access to functionality that was not originally intended. auth //AVOID THIS!
signer.link<auth &ExampleNFT.CollectionPublic{NonFungibleToken.Receiver}>(
    /public/exampleNFT,
    target: /storage/exampleNFT
) Conclusion When developing on the Flow blockchain using Cadence, it helps to be aware of design patterns, anti-patterns, and best practices. By following these best practices, we can ensure a consistent level of security throughout the Flow ecosystem, thus providing the best experience for users. For a more thorough understanding, . read through the Flow documentation Have a really great day!

Flow & Cadence Best Practices, Patterns, and Anti-Patterns

Smart contract development is no different than other types of software development. Code is written to perform a certain task, and there are tools that help make this process easier. The Ethereum ecosystem contains many mature tools to help build Web3 projects, but what about a newer ecosystem, such as Flow? If you’ve been following along with this series so far, you’ll know that the Flow blockchain is optimized for digital asset creation and management. Additionally, its smart contract language, Cadence, improves upon other languages’ pitfalls through its resource-based approach and a strong, static type system. In this article, we’ll take a look at the essential tools smart contract developers can use to make building on Flow easier—tools such as CLIs, IDE extensions, client libraries, local networks, and more. We’ll also contrast these to Ethereum tools you may already be familiar with, so if you’re making the switch to Flow, you’ll know exactly what to expect. Command-line Interfaces Command-line interfaces (CLI) are the bread and butter of software development. They are intuitive for most developers and integrate easily with other software. This easy integration applies to smart contract development as well. For example, if you need to quickly deploy a contract to test it or run it with different accounts, a CLI can help immensely. And later, when you want to add the deployment process to a CI/CD pipeline, you’ll be happy to have a simple CLI tool you can automate with shell scripts. On EVM-compatible networks like Ethereum, Truffle and Hardhat both offer powerful tools for these tasks. The is used for almost all actions with Hardhat, while the __ __enables developers to quickly interact with their smart contracts via JavaScript without having to write script files. Hardhat Runner Truffle Console is the primary tool for developing, testing, and deploying smart contracts written in Cadence to the Flow network. In addition, it’s the interface you use when interacting with the Flow blockchain, such as creating and checking accounts, signing transactions, or automating tasks with scripts. The Flow CLI Unlike Ethereum, where you would generate an address to interact with the blockchain, Flow requires you to have an account. This account holds your smart contracts, tokens, and keys, and is necessary for interacting with the blockchain. You can . easily create accounts using the Flow CLI IDE Extensions Next, you want to write some code, and languages like Cadence and Solidity offer static type checking that gives you some helpful information about how your code will behave in your editor. While Solidity comes with a fundamental type system that prevents you from mixing different number types, Cadence goes a few steps further and introduces the concept of ownership. You might know this from Rust, but the basic idea is that Cadence has resources, like NFTs, that can only be owned by one address. A Cadence IDE extension will notify you about issues with your NFT transactions right at the point when you’re writing the code, while also offering syntax highlighting, code completion, and type checking. Linters You might know linters from languages like JavaScript, where no static typing is available. In this context, a linter helps to prevent common errors and to aid developers in following best practices. The same is true for , a linter tool for Solidity. Again, Solidity’s static type system is very rudimentary and doesn’t prevent many errors while using the language. Solhint comes to aid here and provides tips on top of the type system to avoid misuse. Solhint The Cadence language has a much more sophisticated type system and comes with more help than Solidity. A correctly typed Cadence smart contract is more secure than a correctly typed Solidity one. The typical linter functionality is built right into the Cadence language itself through its type system, but if you want to run type checks on multiple Cadence files inside your CI/CD pipeline, the tool can help. Cadence lint Local Networks A local network, or a network emulator, is a tool that will run a blockchain network on your development computer, so you can test in a clean environment and not risk pushing unfinished smart contracts to a live blockchain. A local network also has lower latency and allows you to control the block creation, so you can step through everything that happens when your smart contract executes. When developing on the EVM, you probably know and use or Ganache for this task. Both tools simulate a blockchain environment on your local machine and allow you to fork a version of mainnet to interact with real accounts and contracts. the Hardhat Network Flow offers a similar feature called that simulates the real Flow network but gives you to interact with. It enables account storage limits, setting initial FLOW token supplies, and enabling persistent state between restarts. This powerful tool is used via the Flow CLI mentioned above and together, they provide all the features developers need to build fully functioning dapps and the environment to test them in. the Flow Emulator more options With the , all one has to do to start the emulator is type the command flow emulator in their terminal. Flow CLI installed Testnet Faucets When developing smart contracts, you typically need crypto tokens to deploy and interact with your code. Otherwise, how will you test transactions? Flow, just like Ethereum, has__ __ that comes with that drips you free testnet FLOW or FUSD for development. a testnet a faucet Additionally, Blocto Swap is a multi-use tool that makes creating an account on Flow simple for users. All one has to do is enter an email address. Blocto Swap allows users to easily exchange their tokens for different types to use in testing. This tool is also a handy way to get FUSD if that collection is not already initialized in the account. : tokens on a testnet hold no value outside of testing. Remember Automated Testing Cadence and Solidity both have test automation tools that allow you to write your tests in JavaScript. The Hardhat development tools use the Chai test runner and supply you with and for the EVM. smart contract matchers network helpers Cadence has that use as the base, but they’re framework agnostic. So if Jest isn’t your thing, you can use a different test runner. its own tools Jest Blockchain Explorers Another vital part of all blockchain networks is the block explorer—a tool that allows you to check out everything that happens on-chain. For the Ethereum network, you might know . It’s a web application that lets you browse mainnet and testnet transactions and addresses. Etherscan Flow comes with a much more powerful tool, ! Flowser Flowser (Flow Browser) is a web application, but you can run it locally. It allows you to browse both the Flow mainnet and any local network you start with the Flow Emulator. It even comes with a GUI to configure and start an emulator and manage your development wallets. However, if all you need to do is check transactions or browse on the Flow mainnet or testnet, then the traditional block explorer__ __ will suit your needs. Flowscan Additionally, the tool allows users to inspect accounts and their various attributes, such as balances, keys, and any contracts they may contain. flow-view-source Interfacing with JavaScript To build a decentralized application (dapp) for your smart contract, you need a bridge between the blockchain network and the web. Flow and Ethereum both come with Webpack integrations to solve this problem. will automatically reload your application when you change your Solidity code, so your frontend always runs with the current version of your smart contract while in development. The Solidity Loader Cadence offers similar features via its and . Webpack plugin the Cadence utilities Additionally, the (FCL) JS is one of the best ways for a developer to quickly start building on the Flow blockchain. This package makes interacting with wallets and smart contracts simple and secure, while providing all the tools necessary to create fully functioning dapps. Flow Client Library Playgrounds Being able to test your code in environments without having to invest the time in creating an entire project enables developers to quickly figure out what works and what doesn’t. To that end, Flow has the . Not only is it an excellent resource to iterate through ideas quickly, it’s also a great environment to learn in, with tutorials included to teach important concepts and how to build common projects. Flow Playground Although Ethereum doesn’t have any projects exactly like the Flow Playground, there are a few you could take advantage of to create a similar experience. The online Solidity code editor, , provides an environment to quickly build and test smart contracts. Additionally, you could follow along with the to help get you up to speed with Solidity and Remix. Remix Developer DAO Academy Summary Software development, and smart contract development in particular, is a complex process that consists of different vital steps. Planning, coding, testing, deploying, and maintenance are all important parts of the process, and having the proper tools at hand makes things easier. Although Flow has a younger ecosystem compared to Ethereum, the tools and libraries available are mature enough to help speed up the development process. From command-line interfaces and IDE extensions to local networks and block explorers, Flow has all the tools an Ethereum developer might be expecting and more. Additionally, the type system and built-in features of the Cadence smart contract language offer controls that Solidity can’t offer without additional tools such as linters. Even then, the value those Solidity tools delivers is inferior to the features Cadence provides natively. Overall, the Flow ecosystem comes with for each step of the development lifecycle. To get started building on Flow, check out their . Developers are also encouraged to share their own tools with the ecosystem, contribute to already existing tools, or to build your projects. all the tools you need Developer Portal apply for grants For a list of other great tools in the Flow ecosystem, . check out this Github repo Have a really great day!

Building Easy Workflows For Web3 Using Flow & Cadence

What is Cadence? The rapid rise in Big Data use cases over the last decade has been accelerated by popular massively scalable open-source technologies such as Apache Cassandra® for storage, Apache Kafka® for streaming, and OpenSearch® for search. Now there’s a new member of the peloton, Cadence, for workflow orchestration. My flatmate used to carry his Cello on a bike to music lessons, a bit like this, but music and cycling also have something more in common — Cadence! In music, .  And in cycling, is how fast the cyclist is pedaling, which influences efficiency and speed. a Cadence is a musical phrase that sounds complete Cadence Workflow orchestration is the process of defining and executing a series of tasks and the order in which they are to be carried out. You may want some tasks to be performed in sequence, but others may be performed concurrently. You also see this idea in orchestral music scores, such as in this example, which provides the conductor, musicians, and choir instructions on what notes to play and when. In typical workflow terminology (e.g., ), a workflow has start and end events, activities (atomic or compound tasks), gateways (decisions), and sequences or flows—the order of activities in a workflow. BPMN In bygone eras of computing, I’ve experienced some of the previous attempts at implementing and modeling workflows, including (Stateful Session Beans were used for workflows), , , and . Traditional workflow modeling uses the semantics of semi/formal notations, including Finite State Machines ( ), , , and to . Enterprise Java Beans ebXML BPEL modeling and evaluating workflows using discrete event simulation FSM Markov Models discrete event simulation Petri networks specify, visualize, and analyze workflows Open source Cadence was developed by Uber and based on the . It uses Apache Cassandra (and other databases) for persistence and is designed to be highly fault-tolerant and scalable. Perhaps the most surprising feature of Cadence, compared to other workflow engine approaches I’ve encountered previously, is that it is focused on helping developers write workflows primarily either in Java or Go (other languages are available), and therefore doesn’t come with any visualization notation or tool to specify workflows, and the semantics are just plain old code. However, it does have the ability (with the ) to visualize workflows as they execute. AWS SWF (Simple Workflow Service) Cadence Web client Now, riding a bike needs a lot of gear. For example, you need a bike (logically), helmet, shoes, water bottle, glasses, gloves, a light, pump, lycra (optional!), etc. Likewise, successful use of Cadence needs a whole bunch of things, including workflows, activities, domains,  workflow clients, and workers. Let’s take a look at each in turn. Cadence Workflows Let’s start with the most basic Cadence concept, workflows. I’ll be using the cadence java client, which requires you to download it and configure it to compile in your IDE of choice (I use Eclipse and Maven, and for simplicity, I’ve omitted the imports). There’s a bunch of java client examples that inspired mine. First, we need a workflow interface and implementation. Workflow interface: static final String activityName = "ExampleActivity";

    public interface ExampleWorkflow {
        @WorkflowMethod(executionStartToCloseTimeoutSeconds = 120, taskList = activityName)
        void startWorkflow(String name);
    } Workflow implementation: public static class ExampleWorkflowImpl implements ExampleWorkflow {
    	
    	private ExampleActivities activities = null;
    	
    	public ExampleWorkflowImpl() {
            this.activities = Workflow.newActivityStub(ExampleActivities.class);
        }
    	
        @Override
        public void startWorkflow(String name) {
        	System.out.println("Started workflow! ID=" + Workflow.getWorkflowInfo().getWorkflowId());
        	
        	String r1 = activities.task1(name);
           String r2 = activities.task2(r1);
            
        	System.out.println("Workflow result = " + r2 + " ID=" + Workflow.getWorkflowInfo().getWorkflowId());
        }
       
    } In Cadence, there’s always exactly one method with the @WorkflowMethod annotation, which acts as the start event for the workflow and contains the sequence flow and activities. Calling it starts a stateful workflow instance, which eventually ends. In the implementation, the method startWorkflow() calls two other methods in sequence (task1, task2), giving us the workflow logic  (simple sequential) and 2 activities. Each running workflow instance has a unique ID, which we’ve used in the above example. You need a workflow ID as workflows can have multiple instances. However, there is some more complexity here. In reality, Cadence isn’t just a POJI/POJO; it is a platform to execute the stateful workflows scalably and reliably. You’ll notice a timeout and activities and taskList above. Timeouts are needed as workflows, like music and cycling, must eventually end. Cadence Activities are a core feature of Cadence. Workflows are stateful and fault-tolerant, but in a distributed microservices architecture, you will eventually want to call remote APIs to perform tasks. However, remote API calls can fail and can’t be made fault-tolerant as they are external to the Cadence workflow. Activities The solution Cadence uses is to allow any code, including remote calls, to be wrapped in a Cadence Activity, with the caveat that Cadence doesn’t recover activity state on failure, and activities are guaranteed to be executed at most once (idempotent activities will be automatically retried on failure, non-idempotent activity failures will need to be handled by business-specific logic including compensation activities, more information on ). RetryOptions can be found here Activities are just a POJO/POJI pair as well, containing the tasks/methods that are to be executed. Each method has a @ActivityMethod annotation with options. public interface ExampleActivities
    {
    	@ActivityMethod(scheduleToCloseTimeoutSeconds = 60)
    	 String task1(String name);
    	@ActivityMethod(scheduleToCloseTimeoutSeconds = 60)
         String task2(String name);
    }

public static class ExampleActivitiesImpl implements ExampleActivities
    {
         public String task1(String arg) {
        	 System.out.println("task1 " + arg + " in " + Activity.getWorkflowExecution().getWorkflowId());
        	 return arg+"task1";
         }

    public String task2(String arg) {
        	 System.out.println("task2 " + arg + " in " + Activity.getWorkflowExecution().getWorkflowId());
        	 return arg+"task2";
         }    
    } We’ve already registered the Activities in the workflow constructor above. Note that there’s a slightly different way required to get the workflow in an activity. So is a Workflow and Activities all we need to get it running? Cadence Domains Cadence has the concept of , which is basically just a namespace that workflows live in. You have to create or reuse an existing domain before you can start workflow or workers. Here’s an example of a method to register a new domain (or return if it exists): domains public static void registerDomain(String host, String domain)
    {   	
    	String nameDescription = "a new domain";
    	
     	IWorkflowService cadenceService = new WorkflowServiceTChannel(ClientOptions.newBuilder().setHost(host).setPort(7933).build());
        RegisterDomainRequest request = new RegisterDomainRequest();
        request.setDescription(nameDescription);
        request.setEmitMetric(false);
        request.setName(domain);
        int retentionPeriodInDays = 1;
        request.setWorkflowExecutionRetentionPeriodInDays(retentionPeriodInDays);
        try {
          cadenceService.RegisterDomain(request);
          System.out.println(
              "Successfully registered domain "
                  + domain
                  + " with retentionDays="
                  + retentionPeriodInDays);
        } catch (DomainAlreadyExistsError e) {
          System.out.println("Domain " + domain + " is already registered")
    } And just in case you are wondering what and are (I did, and we’ll also use these below)! These are in the , which doesn’t seem well documented, but this IWorkflowService WorkflowServiceTChannel ServiceClient package appears to be the main way you connect to the Cadence server. “The ServiceClient is an RPC service client that connects to the cadence service. It also serves as the building block of the other clients.” In the found the following client types (in the and ): client/ActivityCompletionClient, client/WorkflowClient, serviceclient/IWorkflowService (There may be more). java client code, I client package serviceclient package 5. Cadence Workflow Client We’re now ready to try the example. In the main method, here is some sample code to create a domain and a new instance: WorkflowClient String host  = "Cadence Server IP";
    	
String domainName = "example-domain";
    	
registerDomain(domainName);
    	
WorkflowClient workflowClient =
                WorkflowClient.newInstance(
                        new WorkflowServiceTChannel(ClientOptions.newBuilder().setHost(host).setPort(7933).build()),
                        WorkflowClientOptions.newBuilder().setDomain(domainName).build()); Cadence Workers If you try and run the above example, you’ll find that none of the tasks are progressed, and the workflow just times out eventually. What’s gone wrong? The way that activities are executed is by Workers. Workers for the activities need to be created before any work is performed (similar to musicians in an orchestra—you can have a conductor and the score, but the score isn’t actually played until the musicians are on the stage with their instruments, ready to perform, and the conductor starts them off). So now that we have a WorkflowClient, we’re ready to create a worker. You have to specify the String activityName, and register both the Workflow and Activities implementations with the workflow before starting it (if you forget to register the activities, there’s no error, but nothing happens as Cadence will just wait for a worker process to appear, at least until the workflow times out!): WorkerFactory factory = WorkerFactory.newInstance(workflowClient);
        Worker worker = factory.newWorker(activityName);
        worker.registerWorkflowImplementationTypes(ExampleWorkflowImpl.class);

        worker.registerActivitiesImplementations(new ExampleActivitiesImpl());
        
        factory.start(); Note that the workers would typically be run in a separate process to the workflow and for scalability reasons on well resourced (and multiple) servers, as this is where the actual workflow task “work” is really being done. But how many workers do we actually have? There are default concurrency and rate limits, and the default settings from are: WorkerOptions Maximum number of concurrent activities = 100 Maximum number of concurrent workflows = 50 Maximum number of concurrent local activities = 100 Maximum number of activities started per second = 0 (unlimited) I suspect that if you were clever and had sufficient monitoring of the workflows and activities (number and times in each), you could use (which relates concurrency, throughput, and time) to estimate the magic numbers more accurately. , including an explanation of what makes sense. Little’s Law Here’s an example of changing the WorkerOptions defaults Cadence Workflow Execution: Synchronous or Asynchronous It’s now time to start executing a workflow instance as follows: ExampleWorkflow exampleWorkflow = workflowClient.newWorkflowStub(ExampleWorkflow.class);
exampleWorkflow.startWorkflow("workflow 1"); Workflows can be started synchronously or asynchronously. Two start two instances synchronously: ExampleWorkflow exampleWorkflow = workflowClient.newWorkflowStub(ExampleWorkflow.class);
exampleWorkflow.startWorkflow("workflow 1 sync");

ExampleWorkflow exampleWorkflow2 = workflowClient.newWorkflowStub(ExampleWorkflow.class);
exampleWorkflow2.startWorkflow("workflow 2 sync"); And asynchronously: ExampleWorkflow exampleWorkflow3 = workflowClient.newWorkflowStub(ExampleWorkflow.class);

CompletableFuture<String> r3 = WorkflowClient.execute(exampleWorkflow3::startWorkflow, "workflow async");
CompletableFuture<String> r4 = WorkflowClient.execute(exampleWorkflow3::startWorkflow, "workflow 2 async");

      try {
		r3.get();
		r4.get();
	} catch (InterruptedException e1) {
		e1.printStackTrace();
	} catch (ExecutionException e1) {
		e1.printStackTrace();
	} Just remember to wait for the asynchronous workflows to complete (as in this example using get()), otherwise, nothing much will happen (as the workers are in the same thread in this example). Cadence Asynchronous Activities and Blocking Workflows aren’t the only things that can be called asynchronously; activities can be executed concurrently as well. This is helpful when you want to run a large number of concurrent tasks at once and then wait for them all to complete. For example, let’s replace the original startWorkflow(String name) method with a new method startConcurrentWorkflow(int max), and we’ll just reuse the original task1() activity but execute it concurrently: public void startConcurentWorkflow(int concurrency) {
            List<Promise<String>> promises = new ArrayList<>();
            List<String> processed = null;
            try {
                      	for (int i=0; i<concurrency; i++)
            	{
                       		Promise<String> x = Async.function(activities::task1, “subpart “ + i);
            		promises.add(x);
            	}
                
                // allOf converts a list of promises to a single promise that contains a list
                // of each promise value.
                Promise<List<String>> promiseList = Promise.allOf(promises);

                // get() blocks on all tasks completing
                List<String> results = promiseList.get();
                
                int count = 0;
                for (String s: results)
                {
                	System.out.println("Processed " + s);
                	count++;
                }
                System.out.println("Processed “ + count + " concurrent tasks");
            } finally {
                }
            }
        } Note that we have to use the Async.function(activities::activityName, arg) method and the Promise class with methods add(), allOf(), and get() to block correctly until all of the activities are complete. Cadence Restrictions The way that Cadence manages workflow state is “clever”’! Rather than maintaining the state of each stateful workflow instance in a database (which is a typical approach for persistence and reliable workflow engines, but has scalability limitations), Cadence emits state changes to the database as history events, and then if something goes wrong (or even if you sleep in a workflow) it just restarts the workflow and replays the history to determine what the next task is to run. This uses the (similar to the way that Kafka Streams can compute state from event streams or event streams from the state). event sourcing pattern This approach supports large numbers of workflow instances running at once (which is likely for long-running and high throughput workflows) but does have negative implications for long workflows, which require increasingly large histories and replaying of many events to regain the correct state. However, this approach does introduce some important on workflow implementation that you need to be aware of—basically, they have to be deterministic. The has lots of useful methods that can be used in place of unsafe/non-deterministic/side-effect riddled standard Java methods, in particular for time, sleeping, and random numbers. restrictions Cadence Workflow class So that’s just about all I know about Cadence so far. However, there’s a lot more to discover, including how it handles exceptions, retries, long-running transactions, different sorts of timeouts, compensation actions, signals, queries, child workflows, and how you can call remote APIs and integrate it with Kafka (e.g., to send and block/receive a message as an activity).

Spinning Your Workflows With Cadence!

Flow, Decoupling Cadences, and Fixed-Length Sprints

Assessing the Interpretability of ML Models from a Human Perspective

The fight between OpenAI and Google to win the generative AI arms race has all the intensity of the war between Kendrick Lamar and Drake but without the low-blow trash talk. This week, both companies unleashed a dizzying array of updates that say a lot about their strategies: OpenAI: A More Human Gen AI On May 13, OpenAI announced several improvements to ChatGPT including multimodal capabilities. https://www.youtube.com/live/DQacCB9tDaw?si=RyXrifz6jnHbYWCW&embedable=true One feature that has captured the imagination of industry watchers is how ChatGPT is becoming more human. OpenAI demonstrated how the latest iteration of ChatGPT (GPT-4o) can detect emotions in users’ voices, analyze their facial expressions, and adjust its own tone and cadence to match user preferences. For instance, if you request a bedtime story, it can adopt a gentle, whispering tone. It can respond in a playful, sarcastic manner if you want it to. It even has the capability to sing when asked. https://youtu.be/D9byh4MAsUQ?si=DnmC0PteXYgj833j&embedable=true The demonstration immediately drew comparisons to Her, the 2013 movie in which a virtual assistant seduces an introvert… But making OpenAI more human is not in and of itself nothing new. There is a growing trend, especially among Gen Z, to turn to AI for personal companionship. Apps such as Pi offer life coaching in a helpful and conversational manner. Replika is a virtual friend and mental health lifeline. Blush is an AI-generated dating simulator. And there are many, many more examples. OpenAI knows that humanlike AI is the future, especially with Gen Z. Recently, Npj Mental Health Research studied how college students use Replika. The study observed, “Many used Replika in multiple, overlapping ways—as a friend, a therapist, and an intellectual mirror. Many also held overlapping and often conflicting beliefs about Replika—calling it a machine, an intelligence, and a human. Critically, 3% reported that Replika halted their suicidal ideation.” The significance of how ChatGPT is evolving is that OpenAI is making an incredibly popular everyday utility more human. There is no turning back now. Google: Doubling Down on AI-Powered Search At Google’s annual I/O conference on May 14, Google showed that it is leaning into its core strengths with gen AI-powered search. For instance, the AI Overview feature provides a brief, AI-generated answer to searches, along with a series of links to the sources cited in the response. Google is also introducing multistep reasoning (refining search results without requiring multiple searches in the same search session). Let’s say you are searching for a new yoga or pilates studio that is popular, conveniently located for your daily commute, and also offers a discount for new members. Soon, you will be able to ask Google Search to “find the best yoga or pilates studios in Boston and show details on their intro offers and walking time from Beacon Hill.” https://youtu.be/s4InWsd-J6g?si=X429BeoiivA6taTQ&embedable=true If you are an avid user of Google search for wayfinding, you can appreciate how important and valuable multistep reasoning will be when rolled out. The company is also introducing updates to its Gemini gen AI chatbot, including the ability to respond to longer prompts, engage in audio-based conversations, and provide more powerful functionality, including a tool summarizing 1,500 pages of the text uploaded by a user. These are important updates to a tool that I personally find more useful than ChatGPT in many ways. But for Google’s business, it is more critical that the company inject gen AI across its powerful search ecosystem, including Google Search, YouTube, and Email. Search is Google’s bread-and-butter business. And Google is fortifying its moat. Photo by Mohamed Nohassi via Unsplash The fight between OpenAI and Google to win the generative AI arms race has all the intensity of the war between Kendrick Lamar and Drake but without the low-blow trash talk. This week, both companies unleashed a dizzying array of updates that say a lot about their strategies: OpenAI: A More Human Gen AI On May 13, OpenAI announced several improvements to ChatGPT including multimodal capabilities. https://www.youtube.com/live/DQacCB9tDaw?si=RyXrifz6jnHbYWCW&embedable=true https://www.youtube.com/live/DQacCB9tDaw?si=RyXrifz6jnHbYWCW&embedable=true One feature that has captured the imagination of industry watchers is how ChatGPT is becoming more human. OpenAI demonstrated how the latest iteration of ChatGPT (GPT-4o) can detect emotions in users’ voices, analyze their facial expressions, and adjust its own tone and cadence to match user preferences. For instance, if you request a bedtime story, it can adopt a gentle, whispering tone. It can respond in a playful, sarcastic manner if you want it to. It even has the capability to sing when asked. https://youtu.be/D9byh4MAsUQ?si=DnmC0PteXYgj833j&embedable=true https://youtu.be/D9byh4MAsUQ?si=DnmC0PteXYgj833j&embedable=true The demonstration immediately drew comparisons to Her , the 2013 movie in which a virtual assistant seduces an introvert… But making OpenAI more human is not in and of itself nothing new. There is a growing trend, especially among Gen Z, to turn to AI for personal companionship. Apps such as Pi offer life coaching in a helpful and conversational manner. Replika is a virtual friend and mental health lifeline. Blush is an AI-generated dating simulator. And there are many, many more examples. The demonstration immediately drew comparisons to Her Her OpenAI knows that humanlike AI is the future, especially with Gen Z. Recently, Npj Mental Health Research studied how college students use Replika. The study observed , “Many used Replika in multiple, overlapping ways—as a friend, a therapist, and an intellectual mirror. Many also held overlapping and often conflicting beliefs about Replika—calling it a machine, an intelligence, and a human. Critically, 3% reported that Replika halted their suicidal ideation.” The study observed The significance of how ChatGPT is evolving is that OpenAI is making an incredibly popular everyday utility more human. There is no turning back now. Google: Doubling Down on AI-Powered Search At Google’s annual I/O conference on May 14, Google showed that it is leaning into its core strengths with gen AI-powered search . For instance, the AI Overview feature provides a brief, AI-generated answer to searches, along with a series of links to the sources cited in the response. Google is also introducing multistep reasoning (refining search results without requiring multiple searches in the same search session). Google showed that it is leaning into its core strengths with gen AI-powered search Let’s say you are searching for a new yoga or pilates studio that is popular, conveniently located for your daily commute, and also offers a discount for new members. Soon, you will be able to ask Google Search to “find the best yoga or pilates studios in Boston and show details on their intro offers and walking time from Beacon Hill.” https://youtu.be/s4InWsd-J6g?si=X429BeoiivA6taTQ&embedable=true https://youtu.be/s4InWsd-J6g?si=X429BeoiivA6taTQ&embedable=true If you are an avid user of Google search for wayfinding, you can appreciate how important and valuable multistep reasoning will be when rolled out. The company is also introducing updates to its Gemini gen AI chatbot, including the ability to respond to longer prompts, engage in audio-based conversations, and provide more powerful functionality, including a tool summarizing 1,500 pages of the text uploaded by a user. These are important updates to a tool that I personally find more useful than ChatGPT in many ways. But for Google’s business, it is more critical that the company inject gen AI across its powerful search ecosystem, including Google Search, YouTube, and Email. Search is Google’s bread-and-butter business. And Google is fortifying its moat. Photo by Mohamed Nohassi via Unsplash Photo by Mohamed Nohassi via Unsplash

Generative AI Clash: OpenAI’s Emotional AI vs. Google’s Enhanced Search

Colliding Magnetospheres in The Young High-Eccentricity Binary DQ Tau: Flare Analyses

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

In the first part of this series, we explored three foundational marketing strategies to amplify interaction. We emphasized the importance of understanding your audience, as it allows for tailored marketing efforts. We also highlighted the key role of writing compelling content to educate, inspire, and foster engagement. Lastly, we placed a strong emphasis on optimizing user experience, from building user-friendly interfaces to streamlining the onboarding process. In this second part, the aim is to build upon these fundamental principles established earlier, exploring more strategies to maximize user engagement. Fostering Community Engagement Building a community around your product is one of the most powerful things you can do to increase engagement while building trust. A strong community will be vital in creating a sense of belonging that goes beyond your product. Cultivating such a community involves more than just providing a platform for interaction; it requires active participation, genuine connections, and a shared sense of purpose. Ultimately, a thriving community will catalyze growth, driving not only increased engagement but also customer retention and advocacy. Let’s delve deeper into how fostering community engagement can amplify product interaction. Building Online Communities Around the Product When building a community around your product, you want to focus on creating a space where users interact, collaborate and share their product insights. There are several ways and channels to build a community - this decision will ultimately be based on your company objectives and on your audience. For example, if your company’s business model is B2C and your target audience is Gen Z, you might be better off by building a community on TikTok. On the contrary, if you have a B2B business with decision-makers as a target audience, you will be better off building your community on LinkedIn. If you have enough dev resources, you might also opt for your own product-based community - the decision is up to you. Remember, communities can also live outside of social channels, and they can take various forms, including forums, online groups, and even offline events. Regardless of the platform or format, the key to building a thriving community lies in creating a welcoming and inclusive environment where members feel valued and supported. Implementing feedback Feedback implementation is an essential part of fostering community engagement. It allows you to demonstrate to your user base that you value their opinions. Place careful attention to any questions that come through customer service and analyze product usage for engagement assumptions. By leveraging user feedback, you will gain valuable insights enabling you to make informed decisions to improve your product and tailor it to your target audience. Feedback requests could include: Surveys and polls
Feedback forms
User testing
Social listening Effective communication Effective marketing communication is the cornerstone of keeping your user base warmed up through continuous nurturing. Regular updates and announcements When communicating with your audience, regular updates and announcements are essential in keeping them informed about product releases, new features, and other relevant information. Regular communication helps keep your audience engaged and invested in your brand, making sure they stay informed and up-to-date with the latest updates. Some key strategies to improve your communication: Keep a consistent schedule. Whether it’s weekly, bi-weekly, or monthly, build a predictable cadence.
Multi-channel distribution. If your business model allows for it, make sure to distribute your updates and announcements on all channels - this could include via email, social media, and in-app notifications.
Have a clear and concise message. Like with all communication, make sure to keep focus on the most important information.
Engage your audience. If the nature of your communication allows it, always make sure to include a call to action. Nurturing your community Building effective communication goes beyond just sharing updates and announcements—it involves actively nurturing your community in order to build and maintain that level of trust. Your communication should always be tailored to your target audience's needs and pain points - whilst also maintaining your company objectives. Think about it as if you are helping a friend… chances are you wouldn’t just blast them random promotions - you would take your time to craft a message that makes them understand why you are sharing it with them. Then, once you have worked on a more human communication, you can take a step back and see where your more objective-focus CTA can be added. Leverage Data Analytics An effective marketing strategy can’t be such without leveraging data analytics. Data analysis is crucial for making informed decisions. Data gives you valuable insights into user behavior. Let’s explore the importance of knowing your metrics to inform strategic decision-making. Knowing your metrics The first thing you want to do to increase product engagement is to know your metrics. This involves identifying and tracking the metrics that are relevant to your business objectives. If you are looking to improve your sign-up rate, ideally you will want to take a look at not only your average sign-up rate but also at all the metrics surrounding the onboarding process. That could span from email open rates and CTR, to app downloads. Take note of each of these metrics and understand where you are starting from. This will allow you to benchmark against past performance. Your analysis could look something like this: User sign-up rate: 50% User churn rate: 27% App Download rate (paid adv): 5% Top pages viewed: Page 1, Page 2, Page 3, Page 4. The above is solely an example, but make sure to take some time to understand what metrics you are tracking and to analyse them. You might find that you need a specific metric, but you are not currently tracking it or, you might realize that you have been tracking past metrics wrong. This exercise will be your starting point for increasing your product engagement. Market research When analyzing your company metrics, it is also vital to do market research and gather industry and competitor-specific metrics so that you can benchmark against them. By understanding the competitive landscape, you will be able to identify strengths, weaknesses, opportunities, and threats, allowing you to develop more effective strategies, differentiate yourself in the market, and craft a more compelling GTM messaging. Conclusion In conclusion, strategic marketing can help you master product engagement in several ways. By focusing on understanding your audience, crafting compelling content, and optimizing user experiences, you lay a strong foundation for driving increased engagement. Moreover, by fostering community engagement, implementing feedback mechanisms, and nurturing effective communication, you create spaces where users feel valued, heard, and empowered to interact with your brand. Leveraging data analytics further enhances your ability to make informed decisions and tailor your approach to meet the evolving needs and preferences of your audience. Ultimately, mastering product engagement is an ongoing journey, and by implementing the strategies outlined in this two-part series, you will be able to improve engagement and position yourself for success in building lasting relationships with your audience. In the first part of this series, we explored three foundational marketing strategies to amplify interaction. We emphasized the importance of understanding your audience, as it allows for tailored marketing efforts. We also highlighted the key role of writing compelling content to educate, inspire, and foster engagement. Lastly, we placed a strong emphasis on optimizing user experience, from building user-friendly interfaces to streamlining the onboarding process. In the first part of this series , we explored three foundational marketing strategies to amplify interaction. the first part of this series In this second part, the aim is to build upon these fundamental principles established earlier, exploring more strategies to maximize user engagement. Fostering Community Engagement Building a community around your product is one of the most powerful things you can do to increase engagement while building trust. A strong community will be vital in creating a sense of belonging that goes beyond your product. Cultivating such a community involves more than just providing a platform for interaction; it requires active participation, genuine connections, and a shared sense of purpose. Ultimately, a thriving community will catalyze growth, driving not only increased engagement but also customer retention and advocacy. Let’s delve deeper into how fostering community engagement can amplify product interaction. Building Online Communities Around the Product Building Online Communities Around the Product When building a community around your product, you want to focus on creating a space where users interact, collaborate and share their product insights. There are several ways and channels to build a community - this decision will ultimately be based on your company objectives and on your audience. For example, if your company’s business model is B2C and your target audience is Gen Z, you might be better off by building a community on TikTok. On the contrary, if you have a B2B business with decision-makers as a target audience, you will be better off building your community on LinkedIn. If you have enough dev resources, you might also opt for your own product-based community - the decision is up to you. Remember, communities can also live outside of social channels, and they can take various forms, including forums, online groups, and even offline events. Regardless of the platform or format, the key to building a thriving community lies in creating a welcoming and inclusive environment where members feel valued and supported. Implementing feedback Implementing feedback Feedback implementation is an essential part of fostering community engagement. It allows you to demonstrate to your user base that you value their opinions. Place careful attention to any questions that come through customer service and analyze product usage for engagement assumptions. By leveraging user feedback, you will gain valuable insights enabling you to make informed decisions to improve your product and tailor it to your target audience. Feedback requests could include: Feedback requests could include: Surveys and polls Feedback forms User testing Social listening Surveys and polls Feedback forms User testing Social listening Effective communication Effective marketing communication is the cornerstone of keeping your user base warmed up through continuous nurturing. Regular updates and announcements Regular updates and announcements When communicating with your audience, regular updates and announcements are essential in keeping them informed about product releases, new features, and other relevant information. Regular communication helps keep your audience engaged and invested in your brand, making sure they stay informed and up-to-date with the latest updates. Some key strategies to improve your communication: Some key strategies to improve your communication: Keep a consistent schedule. Whether it’s weekly, bi-weekly, or monthly, build a predictable cadence. Multi-channel distribution. If your business model allows for it, make sure to distribute your updates and announcements on all channels - this could include via email, social media, and in-app notifications. Have a clear and concise message. Like with all communication, make sure to keep focus on the most important information. Engage your audience. If the nature of your communication allows it, always make sure to include a call to action. Keep a consistent schedule. Whether it’s weekly, bi-weekly, or monthly, build a predictable cadence. Keep a consistent schedule. Multi-channel distribution. If your business model allows for it, make sure to distribute your updates and announcements on all channels - this could include via email, social media, and in-app notifications. Multi-channel distribution. Have a clear and concise message. Like with all communication, make sure to keep focus on the most important information. Have a clear and concise message. Engage your audience. If the nature of your communication allows it, always make sure to include a call to action. Engage your audience. Nurturing your community Nurturing your community Building effective communication goes beyond just sharing updates and announcements—it involves actively nurturing your community in order to build and maintain that level of trust. Your communication should always be tailored to your target audience's needs and pain points - whilst also maintaining your company objectives. Think about it as if you are helping a friend… chances are you wouldn’t just blast them random promotions - you would take your time to craft a message that makes them understand why you are sharing it with them. Then, once you have worked on a more human communication, you can take a step back and see where your more objective-focus CTA can be added. Leverage Data Analytics Leverage Data Analytics An effective marketing strategy can’t be such without leveraging data analytics. Data analysis is crucial for making informed decisions. Data gives you valuable insights into user behavior. Let’s explore the importance of knowing your metrics to inform strategic decision-making. Knowing your metrics Knowing your metrics The first thing you want to do to increase product engagement is to know your metrics. This involves identifying and tracking the metrics that are relevant to your business objectives. If you are looking to improve your sign-up rate, ideally you will want to take a look at not only your average sign-up rate but also at all the metrics surrounding the onboarding process. That could span from email open rates and CTR, to app downloads. Take note of each of these metrics and understand where you are starting from. This will allow you to benchmark against past performance. Your analysis could look something like this: User sign-up rate : 50% User sign-up rate User churn rate: 27% User churn rate: App Download rate (paid adv): 5% App Download rate (paid adv): Top pages viewed: Page 1, Page 2, Page 3, Page 4. Top pages viewed: The above is solely an example, but make sure to take some time to understand what metrics you are tracking and to analyse them. You might find that you need a specific metric, but you are not currently tracking it or, you might realize that you have been tracking past metrics wrong. This exercise will be your starting point for increasing your product engagement. Market research Market research When analyzing your company metrics, it is also vital to do market research and gather industry and competitor-specific metrics so that you can benchmark against them. By understanding the competitive landscape, you will be able to identify strengths, weaknesses, opportunities, and threats, allowing you to develop more effective strategies, differentiate yourself in the market, and craft a more compelling GTM messaging. Conclusion Conclusion In conclusion, strategic marketing can help you master product engagement in several ways. By focusing on understanding your audience, crafting compelling content, and optimizing user experiences, you lay a strong foundation for driving increased engagement. Moreover, by fostering community engagement, implementing feedback mechanisms, and nurturing effective communication, you create spaces where users feel valued, heard, and empowered to interact with your brand. Leveraging data analytics further enhances your ability to make informed decisions and tailor your approach to meet the evolving needs and preferences of your audience. Ultimately, mastering product engagement is an ongoing journey, and by implementing the strategies outlined in this two-part series, you will be able to improve engagement and position yourself for success in building lasting relationships with your audience.

Mastering Product Engagement: Amplifying Interaction through Strategic Marketing (Part II)

পণ্যের সম্পৃক্ততা আয়ত্ত করা: কৌশলগত বিপণনের মাধ্যমে মিথস্ক্রিয়া বৃদ্ধি করা (দ্বিতীয় খণ্ড)

Produktengagement meistern: Interaktion durch strategisches Marketing verstärken (Teil II)

Dominar el compromiso con el producto: amplificar la interacción a través del marketing estratégico (Parte II)

Maîtriser l'engagement produit : amplifier l'interaction grâce au marketing stratégique (partie II)

उत्पाद जुड़ाव में महारत हासिल करना: रणनीतिक विपणन के माध्यम से बातचीत को बढ़ाना (भाग II)

製品エンゲージメントをマスターする: 戦略的マーケティングによるインタラクションの強化 (パート II)

제품 참여 마스터하기: 전략적 마케팅을 통한 상호 작용 증폭(2부)

Dominando o envolvimento do produto: ampliando a interação por meio do marketing estratégico (Parte II)

Освоение взаимодействия с продуктом: усиление взаимодействия посредством стратегического маркетинга (Часть II)

Ürün Etkileşiminde Ustalaşmak: Stratejik Pazarlama Yoluyla Etkileşimi Güçlendirmek (Bölüm II)

Làm chủ sự tương tác với sản phẩm: Tăng cường tương tác thông qua tiếp thị chiến lược (Phần II)

掌握产品互动：通过战略营销扩大互动（第二部分）

FastAPI Got Me an OpenAPI Spec Really... Fast

ফাস্টএপিআই আমাকে একটি ওপেনএপিআই স্পেক দিয়েছে... দ্রুত

FastAPI hat mir wirklich ... schnell eine OpenAPI-Spezifikation besorgt

FastAPI me consiguió una especificación OpenAPI realmente... rápido

FastAPI m'a offert une spécification OpenAPI vraiment... Rapide

FastAPI ने मुझे एक OpenAPI विनिर्देशन वास्तव में... तेजी से दिलाया

FastAPI で OpenAPI 仕様を本当に早く入手できました

FastAPI를 통해 OpenAPI 사양이 정말... 빨라졌습니다.

FastAPI me deu uma especificação OpenAPI muito... rápida

FastAPI дал мне спецификацию OpenAPI действительно... быстро

FastAPI Bana Gerçekten Bir OpenAPI Özelliği Sağladı... Hızlı

FastAPI đã cung cấp cho tôi thông số OpenAPI thực sự... Nhanh

FastAPI 让我快速获得了 OpenAPI 规范

In today's edition: What does research say about how far we are from AGI? News from the usual subjects: Anthropic, Cohere, OpenAI, etc. The freshest AI&ML research papers from the week of Mar 4 — Mar 10 Though the question, “ ” predates the term “artificial intelligence” itself, it saw a significant resurgence on Twitter last week, prompted by the Musk vs. OpenAI lawsuit (Musk accuses OpenAI of abandoning open-source principles and prioritizing profit over safety, hindering the safe development of AGI.) . Today, we will discuss “How Far Are We from Intelligent Visual Deductive Reasoning?” “How Far Are We From Automating Front-End Engineering?” and Stephen Wolfram’s article “Can AI Solve Science?” These papers offer fascinating explorations of the differences between human and artificial intelligence. How far are we from achieving human-level intelligence in machines (or AGI, or ASI)? But far more interesting were the papers and an article that came out last week tackling this question Intelligent Visual Deductive Reasoning In “ ?”, researchers from Apple explore Vision-Language Models (VLMs), like GPT-4V, in visual-based deductive reasoning, a complex yet less studied area, using Raven’s Progressive Matrices (RPMs)*. How Far Are We from Intelligent Visual Deductive Reasoning *Raven’s Progressive Matrices is a nonverbal intelligence test measuring abstract reasoning, using patterns to assess cognitive functioning without language. What caught my attention was the finding that . The paper notes, “ ” This inability to deal with abstract concepts marks a fundamental difference between computational processing and human cognitive abilities. AI systems like VLMs struggle with tasks requiring abstract pattern recognition and deduction VLMs struggle to solve these tasks mainly because they are unable to perceive and comprehend multiple, confounding abstract patterns in RPM examples. Being a sophisticated pattern recognizer doesn’t equate to sentience. The observation that “ ” highlights , suggesting a nuanced aspect of intelligence that current AI lacks. Another intriguing point was the models’ overconfidence. all the tested models never express any level of uncertainty the importance of doubt and uncertainty in human cognition Automating Front-End Engineers In “ ”, researchers from Stanford University, Georgia Tech, Microsoft, and Google DeepMind have developed a benchmark for Design2Code, aiming to evaluate how well multimodal LLMs convert visual designs into code. Here, the replacement of humans came closer. Despite some limitations, there were considerable advancements in using generative AI to convert designs into front-end code. It’s remarkable that “ .” This finding challenges traditional notions of artistic and creative value, Design2Code: How Far Are We From Automating Front-End Engineering? annotators think GPT-4V generated webpages can replace the original reference webpages in 49% of cases in terms of visual appearance and content; and in 64% of cases, GPT-4V generated webpages are considered better questioning whether creativity is uniquely human or can be algorithmically reproduced — or even surpassed. However, . VLMs struggle with “ ” posing questions about understanding and interpretation. significant limitations persist recalling visual elements from the input webpages and generating correct layout designs. So, the important question is actually not how far we are from AGI (whatever it is), but how we embrace human-AI collaboration most effectively. AI Solving Science In that sense, Stephen Wolfram’s blog post “ ” serves as an excellent example. In the very beginning, he plainly states that AI cannot solve all scientific questions. However, there is significant value in AI assisting scientific progress. He discusses how LLMs can serve as a new kind of linguistic interface to computational capabilities, providing high-level “autocomplete” for scientific work. As he usually does, he emphasizes the transformative potential of representing the world computationally and suggests that pockets of computational reducibility* can be found by AI as well. Can AI Solve Science? *A pocket of computational reducibility — a fascinating concept introduced by Wolfram — is a situation or problem within a complex system where, despite the system’s overall unpredictability, predictable patterns or simplified behaviors emerge, allowing for easier understanding or calculation. Wolfram argues that AI can significantly aid scientific discovery by providing new tools for analysis and exploration, but its ability to completely “solve” science is limited by fundamental principles such as computational irreducibility. The future of AI in science lies in its integration with human creativity and understanding, leveraging its strengths to uncover new knowledge within the constraints of what is computationally possible. We might be able to survive without front-end developers (no offense intended), but scientists remain indispensable! To summarize: https://x.com/pmddomingos/status/1766945083314827455?s=20&embedable=true News from The Usual Suspects © Cohere and its commitment to the research community https://x.com/cohere/status/1767275128813928611?s=20&embedable=true Hugging Face Starting an ambitious open robotics project and hiring , a former Tesla scientist, to expand beyond software into robotics, including work on humanoid robots like Tesla’s Optimus. Remi Cadene Offers an amazing tool: https://x.com/maximelabonne/status/1767124527551549860?s=20&embedable=true Russia’s talent is invisible According to “The Global AI Talent Tracker 2.0”, Russia has no chance in the AI race: this analysis Inflection enhances its Pi Inflection , enhancing its personal AI, Pi, with IQ capabilities alongside its empathetic EQ. They claim to compete with GPT-4, achieving significant efficiency and performance improvements, especially in STEM areas, with less computational resource usage. launches Inflection-2.5 Chips TSMC (based in Taiwan), the world’s largest contract chipmaker, is for an Arizona chip plant. This funding, part of the CHIPS and Science Act of 2022, aims to boost domestic semiconductor production. TSMC’s $40 billion investment in the plant marks one of the largest foreign investments in U.S. history. expected to receive over $5 billion in U.S. federal grants OpenAI: new members on the board Sam Altman is reinstated as a member of the OpenAI board. , with a rich history as the CEO of the Bill and Melinda Gates Foundation, brings extensive experience in healthcare and philanthropy. , a seasoned executive with roles at Sony Entertainment and as a lawyer, offers legal and entertainment industry insights. , leading Instacart and with a background at Meta Platforms, including as head of Facebook, contributes expertise in technology and e-commerce. This diverse trio enhances OpenAI’s governance with their wide-ranging expertise and perspectives. He is joined by three women: Sue Desmond-Hellmann Nicole Seligman Fidji Simo Elon’s Grok https://x.com/elonmusk/status/1767108624038449405?s=20&embedable=true Anthropic Offers a great collection of prompts in its Prompt library Enjoyed This Story? I write a weekly analysis of the AI world in the newsletter. We aim to equip you with comprehensive knowledge and historical insights, so you can make informed decisions about AI and ML. Turing Post 🎁 Bonus: The freshest research papers, categorized for your convenience Enhancements in Language Models and Multimodal Understanding : Showcases an LLM’s intrinsic ability to understand and generate music, expanding LLMs’ applications beyond text. ChatMusician Read the paper : Demonstrates advanced multimodal understanding by processing extensive contexts of text, video, and audio. Gemini 1.5 Read the paper : Enhances TTS synthesis with a factorized diffusion model for zero-shot natural speech generation. NaturalSpeech 3 Read the paper : Utilizes fine-tuned MLMs for superior image-text data filtering, improving dataset quality for MLM training. Finetuned Multimodal Language Models Are High-Quality Image-Text Data Filters Read the paper : Introduces the first LLM designed for the legal domain, demonstrating proficiency in legal text understanding and generation. SaulLM-7B Read the paper Novel Training and Evaluation Techniques : Proposes a method for scaling instruction tuning in mathematical reasoning, significantly enhancing LLMs’ problem-solving abilities. MathScale Read the paper : Reveals redundancy in LLM layers and proposes a pruning strategy, maintaining performance while reducing model size. ShortGPT Read the paper : Enhances memory efficiency in LLM training without sacrificing performance by applying gradient low-rank projection. GaLore Read the paper : Develops a method for collaborative decoding among multiple LLMs, improving performance across various tasks. Learning to Decode Collaboratively with Multiple Language Models Read the paper : Advocates for training RL value functions through classification instead of regression, boosting performance and scalability. Stop Regressing Read the paper Advances in Generative Models and Data Synthesis : Introduces a framework for generating synthetic multimodal datasets, overcoming limitations in data privacy and diversity. MAGID Read the paper : Trains a generative model to create interactive virtual worlds from text, images, or sketches, advancing interactive environment simulation. Read the paper Genie Scalability and Efficiency in AI Systems : Details a system for training LLMs on over 10,000 GPUs, tackling challenges in training efficiency and stability at large scales. MegaScale Read the paper : Improves State Space Models with dense hidden connections for efficient large language models, enhancing performance with minimal parameter increase. DenseMamba Read the paper Exploring New Frontiers in AI and Machine Learning : Illustrates that planning and prediction in time series can be simplified through learned contrastive representations. Inference via Interpolation Read the paper : Employs simulated trial and error for tool learning, significantly enhancing LLMs’ practical application capabilities. LLMs in the Imaginarium Read the paper : Aims to improve context length generalization in LLMs by refining interpolation techniques for out-of-distribution token positions. Resonance RoPE Read the paper : Enhances the localization of behaviors in LLMs to specific components, improving diagnostic capabilities and model understanding. AtP Read the paper : Investigates using world models for enhancing visual representation learning, beyond reinforcement learning applications. Learning and Leveraging World Models in Visual Representation Learning Read the paper Platforms and Tools for Model Evaluation and Interaction : Provides a platform for evaluating LLMs based on human preferences, offering insights into model rankings through pairwise comparisons. Chatbot Arena Read the paper : Explores enhancing LLMs’ reasoning capabilities using RLHF, comparing different algorithms and reward strategies. Teaching Large Language Models to Reason with Reinforcement Learning Read the paper Also published . here

How Far Are We From Human-level Intelligence in AI?

Stories, News & Mentions about CADEN

Caden’s Stories on HackerNoon