Supportbench

supportbench

How to Accept Crypto Payments in a Classic Commerce App

🤔 What is TwNFT? TwNFT is a simple web application that allows you to mint your tweets as for free. NFTs It is my submission for the . Thirdweb x Hashnode Hackathon / Live Demo GitHub Repository 🌐 What is Thirdweb? Getting started with web3 can be difficult even though it is the hype nowadays. We need to write something called a smart contract, which is required to perform actions on the blockchain. To write smart contracts on the Ethereum blockchain, we need to learn a new programming language called . Solidity provides us with smart contracts which have been written by professionals in the field. They also provide us SDKs which makes using these easy. This allows people with basic programming knowledge to make web3 applications with ease. Thirdweb also takes care of deploying these smart contracts to the blockchain. Thirdweb Let us now go back to TwNFT 💡Where did the idea come from? This hackathon was announced back on the 5th of January, 2022 but I didn't get a solid idea until the 18th of January. So where did it come from? I came across an application called from one of @ 's articles. GitNFT lets you mint git commits as NFTs and that is when I thought, "How about minting tweets as NFTs?". GitNFT Chris Bongers I did some research and didn't find any application that did this so it was a golden opportunity for me 🤩 📚 The tech stack What technologies did I use for TwNFT? for the website NextJS for styling TailwindCSS for Twitter authentication and data storage Firebase for deploying the frontend Vercel for the backend API Express to deploy the backend Heroku and of course... for web3 authentication and minting the NFT Thirdweb 🧐 How does TwNFT work? One needs to first sign in with Twitter and then put in the tweet URL for the tweet they want to mint. Before minting, the image that will be minted can also be customized. One needs to assign a name to the NFT and optionally add a description (or else, the tweet's content will be used). Before minting, we have 2 checks to ensure that the person minting the NFT owns that tweet (this is why they are asked to log in with Twitter) and if the tweet has been minted before or not. We don't allow minting the same tweet multiple times, and this is to ensure that every NFT minted is unique. Now let us take a deeper dive into the web3 part A deeper dive into web3 authentication with Thirdweb Setting up authentication with Thirdweb is as easy as adding ~10 lines of code. I am using the package for this application and it is a breeze. The package is easier to implement as it also packs in the UI. However, if you want a custom UI (which I wanted), the hooks package is a better choice. @3rdweb/hooks @3rdweb/react Do note that you need to be using to use any of the aforementioned packages. ReactJS Coming to the code, firstly, you need to add the Thirdweb Provider to the application - import { ThirdwebWeb3Provider } from "@3rdweb/hooks";

const connectors = {
  injected: {},
  walletconnect: {},
};

const supportedChainIds = [1, 4, 137, 250, 43114, 80001];

function MyApp({ Component, pageProps }) {
  return (
    <ThirdwebWeb3Provider
      connectors={connectors}
      supportedChainIds={supportedChainIds}
    >
      <Component {...pageProps} />
    </ThirdwebWeb3Provider>
  );
} Then, it is as easy of using the hook provided to us by either packages to retrieve the function. We have to now just call this function with the wallet type - useWeb3() connectWallet <button
  onClick={() => {
    connectWallet("injected");
  }}
  >
  Login with Metamask
</button> Here is for the wallet injected in the browser. This is in most cases. injected Metamask For a detailed guide on implementing web3 authentication with Thirdweb, check out their . official guide A deeper dive into minting the NFT with Thirdweb I am using the for minting the NFT on the server-side. Minting should take place on the server-side for security reasons. Thirdweb Typescript SDK Minting with the Thirdweb SDK is extremely easy. Let us see how it works - First, we initialize the SDK with our private key. Do keep this secret as anyone who has your private key can gain access to your wallet. I am using for initializing a wallet here. ethers const SDK = new ThirdwebSDK(
  new ethers.Wallet(
    process.env.PRIVATE_KEY,
    ethers.getDefaultProvider("https://rinkeby-light.eth.linkpool.io/")
  )
); Next, we initialize the NFT Module that will let us mint the NFT - const nftModule = sdk.getNFTModule(process.env.NFT_MODULE_ADDRESS); At last, we call the function asynchronously - mintTo const result = await nftModule.mintTo(
  payload.receiverAddress,
  nftMedatada
); Here the result gives us the NFT's . The is a unique identifier for the NFT in that collection. tokenId tokenId Now, that is it. We have minted an NFT!!! For a more detailed guide, you can check out Thirdweb's . official guide on minting an NFT ❓ What was this NFT Module? Thirdweb provides us with many modules and the NFT Collection module is one of them. It allows you to mint an NFT in an NFT collection and that is what we just did!!! The official collection for this project can be found on OpenSea . here 🖱️ Using TwNFT To get started, log in with Twitter and head over to the page. /mint Next, put in the URL to the tweet you want to mint in the textbox on the top and click the arrow - You should now see a preview of the NFT, something a bit like this - Feel free to customize the image by clicking on the buttons on the options bar - Next, click on the "Connect Wallet" button and connect your Metamask wallet. Walletconnect support is coming soon. You should now see a button saying "Mint NFT" instead of "Connect Wallet" on the options bar. Clicking that should bring up this modal where you can fill out the name of the NFT, and optionally add a description - After some time, you should get the option to go to the tweet page - The tweet page will look somewhat like this (do give the image some time to load for the first time) - Notice that it says the NFT is still being minted and it is going to take 5-10 minutes. Check back after 5-10 minutes and this is what the page should look like - The NFT is now under your wallet and you can do anything with it, including listing it for sale, selling it, and even transferring it to another wallet. 🖊️ Sidenote Currently, TwNFT is running on the Rinkeby Test Network. This means all NFTs minted will be on the test network and not on the main network. However, this is subject to change in the future. ✨ Conclusion It has been a great journey over the last 13 days making TwNFT, squashing bugs, and implementing features. Excited to see how it goes 😆 Bye, and have a nice day 😁🤞 🔗 Important Links TwNFT TwNFT GitHub Repository TwNFT Backend GitHub Repository TwNFT OpenSea collection This article was first published here

TwNFT - Mint your tweets as NFTs easily and for free

In this series of three articles, we are going to build a decentralized application with a back-end. We will use rLogin suite, developed by team, which will allow us to build a secure, reliable and scalable application from scratch. RIF Identity The first article is an introduction and explains . It also shows how to perform different operations and interactions with the wallet: send transactions, digitally sign messages, and so on. This will be a pure front-end app at first. Users will be able to join the application with any RSK or Ethereum compatible wallet, even using a mobile phone wallet. This will be powered by library. how to connect to the user’s digital wallet rLogin In the second article, we will build a back-end for this app, using a library, which allows us to . The library enables a secure and simple authentication model where the user needs to digitally sign a message with their wallet. This optimizes the user experience avoiding the need to remember passwords, or receive any emails to validate identity. Express DID Auth authenticate users using their wallet address as a unique identifier Finally, in the third article, we will work with something a little bit more complex: the . This service allows users to have . We make use of the user’s wallet to encrypt files, empowering users with real privacy for their information. This means that even the Data Vault server cannot decrypt your data. The service allows us, for example, to store Verifiable Credentials that can be requested at the time as part of authentication. rLogin and DID Auth integrate this service and make use of this feature, enabling developers to do things that were never possible in the crypto world. RIF Data Vault a user-centric cloud storage for free, where saved files are encrypted on the client side How to connect to the user’s digital wallet In this first article, as mentioned before, we are going to connect to the user’s wallet from a React.js application. To summarize, we are going to: Create a front-end app Add a that requests user’s account and wallet access login button Describe some operations that can be done with user’s wallet Some tiny prerequisites: React.js for the front-end A compatible wallet - you can try with any of – we recommend trying this with a browser wallet and a mobile wallet, to have both experiences these supported providers Let’s start! The app we are going to build is published in this repo: https://github.com/rsksmart/rlogin-sample Create the front-end npx create-react-app rlogin-sample
cd rlogin-sample We have a React.js front-end already created! If you want you can first clean-up a little bit of the UI removing React logo and such. Install rLogin Let’s install . With this library, we are going to display a pop-up that lets users pick any compatible wallet of choice. rLogin yarn add @rsksmart/rlogin @walletconnect/web3-provider With a quick setup, we can enable users to connect to our app using any browser wallet or even any mobile wallet. Connect to RSK Testnet with your wallet (or pick another set of supported networks in the setup). I recommend trying first with that has an easy setup for RSK (just switch network in the top left corner of the wallet), and that support RSK by default. Nifty browser wallet Defiant mobile wallet RLogin, { RLoginButton } WalletConnectProvider { useState } ; ; rLogin = RLogin({ : , providerOptions: { walletconnect: { : WalletConnectProvider, options: { : { : }
      }
    }
  }, : [ ] }) { [provider, setProvider] = useState( ) [account, setAccount] = useState( ) connect = rLogin.connect()
    .then( { setProvider(provider) provider.request({ : }).then( setAccount(account))
    }) ( <RLoginButton onClick={connect}>Connect wallet</RLoginButton> <p>wallet address: {account}</p> );
} App; import from '@rsksmart/rlogin' import from '@walletconnect/web3-provider' import from 'react' import './App.css' // construct rLogin pop-up in DOM const new cachedProvider false // change to true to cache user's wallet choice // read more about providers setup in https://github.com/web3Modal/web3modal/ package // setup wallet connect for mobile wallet support rpc 31 'https://public-node.testnet.rsk.co' // use RSK public nodes to connect to the testnet supportedChains 31 // enable rsk testnet network ( ) function App const null const null // display pop up const => () ( ) => { provider } // the provider is used to operate with user's wallet // request user's account method 'eth_accounts' ( ) => [account] return < = > div className "App" </ > div export default We now have a simple button that, when clicked, displays a pop-up. This pop-up will let user pick their wallet of choice. Once the user accepts, their wallet address will be displayed in the front. Easy!! Operate user’s wallet We are now connected to our user’s wallet and we want to do three things: Get user’s balance Send blockchain transactions Digitally sign messages The last two operations will prompt a notification in the user’s wallet asking for permission to do so. Let’s go for it! Get user’s balance This is one of the most common queries we can do to the blockchain. To do so we are going to execute another RPC request. I also added some code for setting the tx hash to React state. [balance, setBalance] = useState( ) getBalance = provider.request({ : , : [account]
}).then(setBalance) const '' const => () method 'eth_getBalance' params <button onClick={getBalance} disabled={!account}>get balance< p> /button>
<p>balance: {balance}</ Get some funds in the and try it out. RSK Testnet faucet Sending transactions As an example, we are just going to send a basic transaction with no data. It is simple: [txHash, setTxHash] = useState( ) faucetAddress = sendTransaction = provider.request({ : , : [{ : account, : faucetAddress, : }]
}).then(setTxHash) const '' const '0x88250f772101179a4ecfaa4b92a983676a3ce445' // giving back some funds const => () method 'eth_sendTransaction' params from to value '100000' <button onClick={sendTransaction} disabled={!account}>send transaction< p> /button>
<p>txHash: {txHash}</ As mentioned before, this will notify the user asking for approval in their wallet. Once the user accepts, the method will return the transaction hash. This is the unique identifier of the transaction and can be searched in the . RSK Testnet explorer Digitally sign messages This is pretty similar! We just need to request another RPC request, : personal_sign [signature, setSignature] = useState( ) message = personalSign = provider.request({ : , : [message, account]
}).then(setSignature) const '' const 'Welcome to RIF Identity suite!!!' const => () method 'personal_sign' params <button onClick={personalSign} disabled={!account}>sign message< p> /button>
<p>signature: {signature}</ Performing complex transactions Complex transactions, like smart contract operations, can be performed with any Web3 client, such as , or . For example, you can instantiate a object with: web3.js ethers.js ethjs web3.js Web3 web3 = Web3(provider) import from 'web3' const new Other operations Sending transactions and signing messages are just the two most common operations, but with rLogin provider, you are able to perform any operation: EIP-1193 Send transactions Operate with smart contracts Sign messages ( ) EIP-191 Sign typed data ( ) EIP-712 Request user’s accounts Request user’s connected network Listen to network or accounts changes Listen to user disconnection The rLogin library rLogin is a front-end library that was built with one main purpose: to reduce the technical gap for new crypto apps users. Most of our work was put in building a simple and intuitive front-end, that in future versions will include tutorials for each wallet provider. We support RSK Mainnet and RSK Testnet, and also Ethereum and its testnets. The objective of rLogin is to maintain a set of quality assurance tests, making the library a reliable front-end tool to be used along different kind of applications. rLogin adds features to , the Ethereum login tool. For setting up rLogin, you can pick any providers that are supported by , and, in addition, the library also allows setting up a challenge-response authentication model – this will be explained in the following chapter. web3modal web3modal Thanks!! See you in the next edition. We are going to set up a back-end for our dApp! Useful links RIF Identity docs: r https://developers.rsk.co/rif/identity/ Login repo: r https://github.com/rsksmart/rlogin Login docs: r https://developers.rsk.co/rif/identity/rlogin/ Login sample apps: https://github.com/rsksmart/rlogin-sample-apps : web3modal https://github.com/web3Modal/web3modal/ EIP-1193 - Ethereum Provider JavaScript API: https://eips.ethereum.org/EIPS/eip-1193 RIF landing: https://rifos.org Ilan Olkies Github: @ilanolkies Twitter: @ilanolkies

rLogin: The New Authentication Libraries for Blockchain Based Apps

- “Staking liquidity essentially gives token holders a passive income, while bolstering the overall health of the decentralized network.” Cryptoslate If you’ve spent any amount of time in the crypto world, you’re well aware of staking. But did you know that you can now stake tokens on to help your favorite crypto projects and earn staking fees in the process? You can do so simply by buying Relay Tokens. Bancor How Do I Stake on Bancor? In order to stake, all you need to do is buy Relay Tokens and hold them in your wallet. You can find Relay Tokens by looking for the addition of ‘BNT’ to existing token names. For example, the Relay Token for PEOS is . ‘BNTPEOS’ Buying Relay Tokens and leaving them in your wallet is the definition of staking on Bancor. You can sell your Relay Tokens at any time just like you would any other tokens on Bancor. allow all the tokens on Bancor to be easily converted to other tokens in a single transaction. Relays How Can I Earn Staking Fees? You earn a portion of the staking fees whenever someone does a conversion that involves the Relay you just bought and are holding. The portion of the fees you earn is in proportion to the percentage of the Relay you own — for instance, contributing 20% of the Relay’s liquidity will entitle you to 20% of each conversion fee. When you sell your Relay Tokens (for example, when I convert BNTPEOS into PEOS), you know the cumulative amount of staking fees you earned. Keep in mind you can sell your Relay Tokens at any time. There’s no time limit. But also be advised that the price of tokens in the Relay may change regardless of accumulated fees, thereby affecting the price of the Relay Tokens. The Bancor team has stated that new tools are coming soon which will allow the community to easily track these price movements and to help optimize Relay Token returns. What Are Relays? Here’s the official definition of a Relay from the : Bancor Support website “You can think of a Relay as a balance scale with each side representing the total supply of one connector. The way to buy tokens from one side of the scale is by adding tokens to the other side. The Relay does not know what the market deems a fair price for each connector, it only knows that each side of the scale represents the same amount of value. For example, if we were to create a Relay named BNTENJ, where one connector has a balance of 1,000 ENJ tokens and another connector balance of 10,000 BNT tokens, the Relay will function with the value of 1 ENJ = 10 BNT. If someone tries to buy 1 ENJ from the Relay, they will need to send the Relay’s converter 10 BNT tokens. After that transaction occurs, the supply of the tokens in the relay changes, and now the Relay assumes that 999 ENJ = 10,010 BNT.” Learn more about Relays in this video: How Bancor Relays Work How Are Staking Fees Generated? You might be scratching your head right now and thinking, “But wait, I didn’t think Bancor took a fee for converting tokens?” You’re correct. Relays generate a liquidity provider fee with each conversion they process. These fees act as an incentive to users providing liquidity on the network. Now it’s time to buy and stake Relay Tokens on Bancor. Below you will find two tutorials. The first tutorial explains how to buy and stake Relay Tokens for the Liquidapps project, BNTDAPP, using the native . The second tutorial shows how to buy and stake PEOS Relay Tokens which are called BNTPEOS using the Bancor wallet Scatter wallet. Tutorial #1: Stake BNTDAPP Relay Tokens & Pay With ETH Video Tutorial: Blockchains: Ethereum and EOS Wallet: Bancor Wallet Action: Buy BNTDAPP Relay Token with ETH (BNTDAPP is from LiquidApps’ DAPP Network https://medium.com/@liquidapps) STEP 1: Go to and log into your account. https://www.bancor.network/ STEP 2: Choose which token you want to PAY WITH from the first dropdown menu. Example: ETH STEP 3: Choose what Relay Token you want to RECEIVE on the second dropdown menu. Example: BNTDAPP STEP 4: Hit the button CONVERT. You’re now staking on Bancor by purchasing and holding BNTDAPP Relay Tokens. Tutorial #2: Stake BNTPEOS Relay Tokens & Pay With EOS Using Scatter Video Tutorial: After buying your desired Relay Token, you’re now actively staking on Bancor, helping your favorite crypto project become more liquid, plus earning some fees from each conversion processed by the Relay. As this staking feature is new, I have not tested out the amount of earnings one can make with staking fees. You can monitor the price of each Relay Token using the Relay Token pages. For instance, the Relay Token page for DAPP is , while the Relay Token page for PEOS is PEOS. https://www.bancor.network/token/BNTDAPP https://www.bancor.network/token/BNT You can also use Etherscan to monitor the percentage of the Relay you currently own. See instructions for checking Etherscan in . Bancor’s staking user guide Stay tuned to learn more about analytics tools to help you monitor and optimize your Relay Token holdings. About The Bancor Protocol Bancor is an on-chain liquidity protocol revolutionizing the way people create and share value by enabling constant convertibility between tokens. Conversions via Bancor Protocol are executed against on-chain liquidity pools using automated market makers to price and process transactions without order books or counterparties, allowing for faster, cheaper and more predictable conversions across 11,000+ ERC20 and EOS token pairs, including non-custodial conversions between blockchains. To get the full details from the official Bancor help page about Relay Tokens and staking, go here: https://support.bancor.network/hc/en-us/articles/360031705151

Staking Tokens on the Bancor Network: A Step by Step Guide

(Even More) Functional Elixir — 1 If you (like me) got into Elixir from an object-oriented language, then concepts like may not be very familiar. Some of them do not apply by default to Elixir. But they are part of the and worth exploring. currying, function composing and pointfree functions general functional programming (FP) concepts I started with this free book recommended by a colleague: . I would recommend it to anybody getting into functional . It uses and a few libraries to exemplify the concepts. Yet, JS is not my main language, so I’m very curious to see how those apply in Elixir. Professor Frisby’s Mostly Adequate Guide to Functional Programming programming JavaScript Anything those days is about cryptocurrencies. To keep up with the trends let’s build a small crypto price checker. Then we will refactor it using FP concepts. Initial Implementation The public function takes the amount in GBP as only argument. It outputs the number of crypto-coins you can buy with. Example: buy_crypto_with_gbp(2000) =>[BTC: 0.18983617051918897,ETH: 1.9337893873932355,LTC: 10.66955239648603] The role of the module is to communicate with the external APIs and return the exchange rates. You can find the implementation in the . It exposes 2 public functions: Support Github repo # exchange rate between 2 currenciesexchange_rate("USD", "GBP") => 0.7463 # exchange rate between crypto and USDlist_crypto_usd() => [BTC: 14256.67, ETH: 1371.76, LTC: 262.51] There are a few simple actions happening in the code above: get a list of the 3 cryptocurrencies prices in USD get an exchange rate between 2 currencies convert the list of crypto prices from USD to GBP. map the quantity for each crypto-coin The challenge is to refactor the code above using the functional concepts of currying, composing and pointfree. Curry, Compose, Pointfree First of all, I must say that those concepts are not provided with Elixir out of the box. We could implement some of them on our own, but it’s safer and easier to make use of this amazing package: . You may say that we can already compose functions in Elixir with the pipe operator. Stay with me, the composing we are going to use is slightly different. Add the Quark package in the mix file, and at the top of the module. Quark |> use Quark Currying Is the ability to call a function that takes many arguments, with one argument at a time. Each time it will return a new function until the last argument is applied and the result is returned. Quark defines currying with or for private functions. defcurry defcurryp Let’s start by determining the exchange rage from USD to GBP. Add a wrapper around our function: Support.exchange_rate/2 defcurry exchange_rate(from, to) doSupport.exchange_rate(from, to)end Now you can start to apply the arguments one by one to our new function. You can assign the partial result (which is a function) to a variable. Or it can become a new function definition: # apply argumentsexchange_rate.("USD").("GBP") => 0.7463 # assign resulting function to a variablefrom_usd = exchange_rate.("USD") => #Function<5.65603100/1 in CryptoCurry.exchange_rate/0> from_usd.("GBP") => 0.7463 # new function definitiondef exchange_rate_from_usd doexchange_rate().("USD")end exchange_rate_from_usd.("GBP") => 0.7463 Next step is to apply the conversion above to the cryptocurrencies info we receive . We use the same function defined in the Initial implementation, but we just currying it: {BTC: 14256.67} apply_conversion/2 defcurry apply_conversion(rate, {crypto, value_usd}) do{crypto, value_usd * rate}end If we follow the same logic as above we can now do the following to the bitcoin value in GBP: apply_conversion_gbp =apply_conversion.(exchange_rate_from_usd.("GBP")) => #Function<7.34465968/1 in CryptoCurry.apply_conversion/0> apply_conversion_gbp.({:BTC, 14265.67}) =>{:BTC, 10646.469520999999} Getting a bit confusing? This is where the next concept may come handy. Composing The Elixir pipe operator takes the output from the expression on its left side and passes it as the first argument to the function call on its right side. |> The composing is very similar, only it passes a function as the argument to another function. It can be: right to left — the mathematical way — represented with <|> left to right — the flow way, as the Elixir pipe — represented with <~> Let’s look at a small example outside our test application: In this case: bazz_rl.("a").("b") == bazz_lr.("a").("b") Back to the crypto example, we are going to keep close to the FP book and use the mathematical way of composing. We want to define a function that will take the crypto data and convert it to GBP. def apply_conversion_gbp do(apply_conversion() <|> exchange_rate_from_usd()).("GBP")end will partially apply as its first argument. The resulting function will be called with the attribute. The result is, of course, another function that can be called with crypto data: apply_conversion exchange_rate_from_usd "GBP" apply_conversion_gbp.({:BTC, 14265.67}) =>{:BTC, 10646.469520999999} We are almost there. Need a function that will return the quantity of coin that we can buy with the amount of GBP. We already have that function from the Initial implementation. Just need to curry it. defcurryp get_quantity({crypto, value_gbp}, amount) do{crypto, amount / value_gbp}end Mapping and composing If you remember from the Initial example, we were iterating twice over the crypto data list. Once to apply the exchange rate and then to get the quantities: Support.list_crypto_usd()|> Enum.map(&apply_conversion(Support.exchange_rate("USD", "GBP"), &1))|> Enum.map(&get_quantity(&1, amount)) This can be inefficient, but math helps us again here: map(f2) <|> map(f1) == map(f2 <|> f1) So we can compose the 2 functions and map them only once. def convert_gbp_and_get_quantity doget_quantity() <|> apply_conversion_gbp()end defcurry buy_crypto_with_gbp(amount) doEnum.map(Support.list_crypto_usd(),&convert_gbp_and_get_quantity().(&1).(amount))end Our application is now in working state. buy_crypto_with_gbp.(2000) =>[BTC: 0.19774571082071027,ETH: 2.0169243958209693,LTC: 11.090413196189877] Pointfree This last step is a cosmetic change in our case. It was the only reason we curried the . buy_crypto_with_gbp/1 Pointfree is the ability to declare the function without mentioning the arguments. We use the Quark package to define a pointfree interface function for our application. defx defx buy_crypto_with_gbp dobuy_crypto_with_gbp().()end Which we can then call with buy_crypto_with_gbp(2000). Putting it all together Quite a long journey, but we’ve made it. Implementing crypto converter using FP concepts. Back to Elixir Yet, keeping some of the learnings from the implementation above, we can refactor our Elixir code, without curry or need for additional libraries. Conclusion If I would need to choose between and implementations above, I would go for the last one. I find the Elixir native way more clear and explicit. CryptoCurry CryptoElixir Currying and composing functions can DRY your code. Can help building specialised functions generic ones. Also, the code may look cleaner as function names are shorter, without so many arguments. But on longer term, or for new people in the project, it can be confusing. Let’s take our example. I see that is called with 2 successive arguments. But I cannot be sure if that is just a partial application or not. I don’t know if it returns a final result or another function waiting for more arguments. convert_gbp_and_get_quantity In the end, it is important to know that we have the option to use those concepts in Elixir as well. Especially if you have a functional background, you may miss them sometimes. I hope the post gave you at least some basic idea about curry, composing and freepoint in Elixir. I would be very curious to find your opinions on Elixir and those FP concepts. If you worked with them in other languages, do you need them in Elixir? If you didn’t, would you consider using them?

Stories, News & Mentions about SUPPORTBENCH

Supportbench’s Stories on HackerNoon