Via Protocol

viaprotocol

A Comparative Study On Mass Adoption Strategies In Web3 

Back in DeFi Summer, the mania for user deposits in exchange for rewards dominated the incentive programs of most DeFi protocols. Nevertheless, the flaws of such imprecise enticement started to attract mercenary farmers instead of protocol users. It turns out that high APR numbers caused some users to overlook the evident fact that farming rewards are harvested in the form of native protocol tokens. Masterchef.sol The most famous contract for DeFi developers already has proven how powerful copy-pasting can be. is one of the most forked contracts in crypto GitHub. The convenience has gotten to a point that all of its functions tend to remain unchanged. Looking back in history, some will remember how this contract emerged to draw liquidity out of back in 2020. Masterchef.sol Uniswap The team deployed this double-edge sword on a ferocious attempt to incentivize any assets locked up in LP token with SUSHI token emissions. A new way of token rewards emission was just born and quickly became a popular way to attract capital deposits. Sushiwap Looking at the following , the result shows a total of 40K farm entries and exits. Did the duration between farm entries and exits kill “DeFi 1.0”? The chart below represents “farming stickiness”. This addresses the duration of tokens locked within a farm. report by Nansen 42% of yield farmers entered within the first 24hours since the pool was deployed 16% of farmers left within the next 48 hours By the third day, 70% of users will have withdrawn from the contract Are governance tokens the “crypto-equivalent of authorized but unissued shares”? According to native tokens in DAO treasuries are the “crypto-equivalent of authorized but unissued shares.” This means that liquidity mining puts new tokens into circulation via liquidity incentives, which in return end up leading to selling pressure. Hasu and Monetsupply As an example, this compares the number to the amount of grant money paid out over that same period. financial statement by Messari The top 100 accounts accrued 69% of all COMP tokens mined Only 19% of COMP holders have kept an amount greater than 1% of their claimed COMP Only 7% of COMP holders have kept an amount greater than 50% of their rewards Paperhand killers Fresh deposits, bonds, time-weighted voting, and DAO-to-DAO stable coin issuers are just some of the latest advancements proving its potential to disrupt how DeFi protocols appeal fresh deposits. These strategies come in the form of a new wave that manages and directs large sums of capital via “protocol owned liquidity”. The next iteration of “free digital money” is starting to come with DeFi 2.0. Here’s why: Information has become a commodity on the Internet. Its value can now be harnessed in Web3 Liquidity management in DeFi is the equivalent of data storage in Web2, where cloud services command the services of computing and storage. Its equivalent in DeFi is “Liquidity as a service” in the form of lending, automatic market making… Remove the selling pressure on native governance tokens However, just like in the traditional world, whoever controls liquidity will end up “dominating DeFi”. Whichever protocol wins the “Vampire wars” will initiate a monopoly of its own. Rotating TVL from one protocol to another can’t last for too long though. Why? Temporary farmers will take their rewards and go away. “I think liquidity mining is one of the dumbest things happening right now in crypto,” Hasu Let’s look at the alternatives that seek to harness liquidity via transparent payoffs. Here’s is a step-by-step roadmap of a scheme that seeks to address the concerns of liquidity mining: Distribution strategies and this practice could only be held back if one side of the market was incentivized: either lenders or borrowers. suggests incentivizing the lending side to “reduce the practice of recursive borrow/lending while still attracting this target user profile.” Recursive borrowing and lending is not sustainable Alex Kroeger that specify how many reward tokens are redeemable while retaining governance rights Vesting schedules those who put time and effort into the protocol will be much more aligned with its success in the long term. By giving users an explicit voice in governance, the subjectivity of determining the “highest impact” contributions to be diminished and agreed upon via community multisigs. Governance mining: The bribe games in the form of voting escrows that lock tokens for prolonged periods of time in exchange for voting power. By locking a portion of their CRV rewards, individual farmers could direct even more rewards to their favorite pools and secure greater profitability in the long run. This process known as “genomics” centralizes governance via token accumulation. Whoever controls the vote-locking systems will end up controlling rewards emission. “Vote locking” promise to ensure healthy liquid markets while granting transparent costs and payoffs. The Bribe ecosystem, therefore, serves as middleware to the governance layer. This allows to “bribe” vote-escrowed holders to direct liquidity to the pools that are most important under their principles. Beware of the importance of versus “The Bribening”: token holders individual farmers. Users provide funds in exchange for token rewards which can be used to vote on where liquidity will be deployed. Vote acquisition via “Market-making venomics”. Protocol owned liquidity or impermanent loss mitigation seeks to pair native governance tokens with stablecoin pairings with liquidity pools. “Risk tranching” , protocols exchange liquidity pool positions for bonds. By doing this the protocols control the liquidity of their token “Bonding” Once the high APY has provide a competitive-enough edge and the treasury has consolidated its token, it is no longer necessary to keep on rebasing. This next iteration aims to raise funds vis SPAC, where the treasury remains intact and keeps growing upon farming and investment revenues. “Olympus forks 2.0”: Moving forward Liquidity as a service has already proven that it can become one of the emerging narratives for 2022. Now it is time for the users to decide whether “curve wars are dumb”, “Olympus forks are a Ponzi”, or “governance-control is centralized”… Today, January 23, 2022, with a few hours remaining for a screenshot that seeks to solve the flaws of liquidity mining, the DeFi narrative will show the entire crypto ecosystem whether being “bullish on experimentation” can pay off the decline of the orange coin. This article was also published here

“Liquidity mining is one of the dumbest things happening right now in crypto,” says @hasufl

Hello everyone! I was inspired to write this article by my students and also I wanted to arrange my thoughts about hiring new test automators since I'm a on the current project. QA Automation Lead Plan So let's define these things that expose juniors and then talk about them in more detail: SSH keys usage Hardcoding sensitive data Using full URLs Waits that are not connected to events Chrome DevTools usage It's not a full list, of course, but these are 5 common criteria that we are going to talk about. SSH keys usage is the most popular version control system and if someone writes code in the development team - they are definitely using to manage their code. Git Git Platforms like , and have a method to checkout code using : web URL and username + password authentication. This is the method that most beginners use. GitHub GitLab, BitBucket HTTPS Professionals use keys to work with repositories and to connect to various remote servers via protocol. SSH Git SSH Hardcoding sensitive data Another thing that juniors do is hardcoding some sensitive data like logins, passwords, and other credential data like authorization tokens. Of course, it gets the job done since your tests will do what they are meant to, but you might have critical vulnerabilities if you choose this method (and most companies don't allow that). One of the right ways to store your sensitive data is to use environment variables that are not going to be logged anywhere in your tests run and of course which won't be reachable from anyone who are not meant to have access. Environment variables may be set in your pipelines options, all popular tools support this (Jenkins, CircleCI, GitLab CI, GitHub Actions and et cetera). CI/CD DevOps Using full URLs See, since there are usually multiple environments that are going to be tested (let's say, production, staging, development...), then you're going to have a different base for each environment. URL For example, your base (and probably your production one) will be: , so your environment-specific are going to be: URL example.com URLs - for production example.com - for staging stage.example.com - for development dev.example.com It means that you should use paths only and set a configuration for each environment (base URL, browser, test runner options, hooks, etc.). So in your tests should look like this (example for JavaScript): URLs URL = ` /main` ${baseUrl} It says that your will be set considering the chosen environment in your test run configuration. For example, if you chose staging, your will look like this: URL URL stage.example.com/main Waits that are not connected to events This is my favorite one since a lot of love to put some specific timeouts in their tests. They don't like to wait for some trigger event, it's much easier to put some timeout specified in seconds and try to perform your next actions then. UI Test Automators It's pretty obvious why this behavior is bad: Sometimes waiting for some web elements to appear or become clickable takes too long, since most of the modern frontend is dynamic and some functionality is based on . It means that in cases where it takes long for a specific behavior to occur, then we need to wait that specific amount of time that might unusual for our test case (let's say that we were waiting 2 seconds for button to appear, but next time it appeared in 10 seconds). AJAX Since most of the elements usually appear fast (in less than a second) and other behaviors occurs fast as well, we will have huge idle segments in our test cases which are going to be just waits. It means that our test runs will take an abnormally long time to run when they could run 2 or even 3 or more times faster using explicit and implicit waits. These arguments that I've stated above also confirm that static waits make our tests (flaky). fragile Professionals use smart waits in all cases where we must wait for something in tests. Smart waits are implicit and explicit ones, when we set a timeout for specific conditions to be completed, so we wait just enough for these events and do our next steps right away, without wasting any time. Chrome DevTools usage is the most popular web browser. More than of internet users prefer it for their daily browsing and development. Google Chrome 65% , like other browsers, has developers tools, which help developers and testers in development to test and debug processes. Chrome What any that works with needs to know: QA Engineer web UI Reading logs from (logs, warnings, errors). Console Running code in console. JavaScript DevTools Using tab to see what requests your web application sends to your server (websocket messages would be a huge plus). Network API Using tab to navigate through tree, modify it and create selectors (XPATH, CSS) for your tests. Elements DOM UI So this final paragraph is actually not just for , but it's also a for manual . Test Automation Engineers must-have QA Engineers Thanks for reading, I hope you've learned something new and now know what to improve if you're an that recently started a career in . Engineer Test Automation I also hope that it's been helpful for those that are going to hire a skilled and were looking for criteria that expose beginners. Test Automator

5 Common Beginner Mistakes in Test Automation

It’s not often that you see a technological boom inside of another breakout, but that’s precisely what is happening in the crypto markets currently. The DeFi ( ) sector, which seeks to revolutionize the current centralized financial system by introducing various decentralized replacements, is also experiencing a deflationary yield farming boom. decentralized finance Traditional Yield Farming Of these new protocols, is arguably the most hyped, and for a good reason. Yield farmers function as mini-banks within a decentralized network. Specifically, they take the place of centralized lenders. For the process to work and remain decentralized, giant liquidity pools are used. yield farming A liquidity pool is simply a smart contract designed to hold many people’s funding at once. Lenders lock their cryptocurrency up in these contracts in exchange for rewards. The process of locking your crypto into smart contracts for rewards is called staking. It was first pioneered as a way to secure Proof-of-Stake blockchains. However, there are many reasons to stake your crypto nowadays. How Yield Farming Works Yield farming lenders stake their crypto into large lending pools with other users. Network participants can then borrow from these pools with interest. Notably, in most networks, the interest and repayment go back into the pool to boost liquidity. Best of all, the lender receives their timely compensation regardless of the loan recipient’s repayment time as the entire system is designed to share funds between participants. Inflationary Risks Every time a new investor joins a liquidity pool via staking, they receive tokens representing their investment. These pool tokens also represent the market value of the liquidity pool. As more people join the pool, the token's value rises. This strategy creates another revenue-generating mechanism for investors. Issues Emerge Following a string of publicized market retractions, DeFi developers began to with the traditional yield farming model. Mainly, there was no way to remove tokens from the liquidity pool without removing liquidity. This lack of control measures leaves yield farming platforms at serious risk of inflation. It wasn’t long before developers decided to nip these issues in the bud. Their answer to this problem was the introduction of deflationary yield farming networks. notice problems Deflationary Approaches to the Problem Deflationary yield farming platforms operate in the same manner as non-deflationary networks. However, they introduce various protocols that remove or lockup tokens from circulation. There are a lot of different ways to deflate a yield farming pool’s token value. Each platform has a different approach to this dilemma. The obvious way to do this is through a token burn. Token burns permanently remove tokens from the market and are very effective at combating inflation. Yield farming networks can control their token’s value more precisely using these next-gen protocols. Consequently, there is a rush of new deflationary yield farming platforms now available to the public. Not every deflationary platform is worth your time. The market is filled with new projects that range in quality from outstanding to . As a new investor, it’s recommended that you only stick with reputable networks. Here are three deflationary yield farming platforms worth checking out. outright scams Flaming Farm is a proprietary deflationary yield farming protocol. When investors join liquidity pools on Flaming Farm, they automatically enjoy the network’s burning system. Flaming Farm Unique deflationary system audited Built-in swap feature Progressively adjusted APY With its FFARM token deflationary systems, Flaming Farm wants to demonstrate the true spirit of DeFi. The burning rate starts at 2.5% in every transfer, and every time supply increase by 2k, the burning rate increase by 0.5%. FlamingSwap is in final testings too. Not forgetting they pretend to enter the gaming industry. Flaming Farm leverages a transparent community governance model to approve significant network changes. Users can vote on important matters, such as adding new liquidity pools to the platform. The users' voting power is determined by the amount of FFARM tokens they hold. This strategy eliminates malicious parties from the community because they would need to commit to the project to have a say. As such, they would only hurt their own ROI. DeFi Yield Protocol (DYP) The (DYP) utilizes a different type of deflationary protocol to keep inflation at bay. While other platforms conduct burns based on liquidity pool stats, DYP leverages a buy-back mechanism to remove tokens from the market. Specifically, 75% of the platform's automated Earn Vault profits go back to liquidity providers. The remaining 25% of profits get sold and used for the token buyback program. This system removes centralization from the network and helps to maintain token price stability. DeFi Yield Protocol also takes focus on removing whale manipulation from the DeFi space forever. The platform leverages an innovative Anti Manipulation protocol that ensures that the rewards from supported tokens (DYP/ETH, DYP/USDC, DYP/USDT, and DYP/WBTC POOL) are automatically converted from DYP to ETH at 00.00 UTC. Besides, rewards are automatically distributed to liquidity providers on the platform in a fair and transparent manner. Thus ensuring that no whale would be able to manipulate the price of DYP to their advantage. This after all is the major purpose of decentralized finance. DYP Also if the price of DYP is affected by more than -2.5, then the maximum DYP amount that does not affect the price will be swapped to ETH, with the remaining amount distributed in the next day’s rewards. After seven days, if they are still undistributed DYP rewards, a governance vote will be held on whether the remaining DYP are distributed (again with the slippage tolerance of -2.5%) to token holders or burned. Yoink Yoink a proprietary distribution model to combat inflation in its ecosystem and keep investors happy. The network functions through the use of a "Piggy Bank." This bank is a smart contract that also provides lottery-style winnings to users. This smart contract was built to hold 30% of the total YOINK supply. introduces The Piggy Bank automatically rewards users via a 1% random payouts protocol. Impressively, anyone has a chance to win these rewards that equal out to an average of around $2000 a day. To be eligible to receive these winnings, you need to be in the top 500 YNK token holders.  When the Yoink protocol selects a wallet that isn't in the top 500, it burns those tokens. Consequently reducing the total supply of YNK tokens and eliminating the risk of inflation. The Implications of Deflationary Yield Farming Deflationary yield farming seems to shake up the market moving forward. Investors already are migrating over to deflationary alternatives in masses. Soon, deflationary yield farming protocols could become the new standard because it provides investors with more security and projects with more stability. Deflationary DeFi - The Next Big Thing It appears as if the DeFi Yield Farming craze has just begun. The introduction of deflationary protocols is sure to draw even more investor interest in the sector. For now, these platforms represent pioneering efforts to combat inflationary concerns on decentralized networks. You can expect to see even more concepts come to light as more platforms seek to catch the yield farming wave. : Disclaimer Most of the DeFi assets are experimental and you should exercise extra caution while interacting with them. The analysis performed in this article is only for educational and informational purposes. The author of this post may or may not own the DeFi Tokens mentioned.

A Look into the DeFi Deflationary Yield Farming Boom

In many blockchain platforms such as and , data confidentiality is a kind of item in their blockchain framework. In these distributed blockchain platform transactions are executed in every participant node in the network. So, every transaction in the network can be visible to all the peers. The ledger update process through all the endorsed peers and has to reach an agreement among all before it committed successfully to the ledger. So, in this scenario creating a private record and comprises within a certain group of participants in the network is a complete “ ”. Ethereum Bitcoin excluded No Why Private Data? In today’s enterprise business sector data confidentiality is a real biggest challenged for the companies. Many competitors in the market seek data privacy and confidentiality for their clients. But all the major blockchain platforms provide a platform and their architecture doesn’t provide such facility to create a transaction for certain groups. Permissionless In this case, Hyperledger Fabric utilizes the opportunity of controlling as a platform enabling structured architecture. We will see in the course of this article, how the Transaction flows with Private data architecture in Hyperledger Fabric. Permissioned Private Data Transaction flow with Private Data In Hyperledger Fabric, there are many different approaches to create private transactions among a few organizations and discarding the visibility of the content of the transaction from other organizations. In the first approach, there are can be separate individual channels for certain organizations only, so whichever organizations are authorized to see the private data can only join the channel. But creating a private channel creates additional administrative overhead and makes process complex to maintain the version, policy, and other configuration details. Chanicode So, there is another structural procedure by creating for certain organizations. The private data collection will be stored in a side database called . The side database is only accessible to authorized organizations. The does not see the private data but can only process the hash of private data to all the endorsed peers in the network for validation and ledger update process. Yes, all the remaining participants will get a copy of private data with hash encrypted. Private Data Collection SideDB Ordering Service In comparison with the Ordering Service Transaction flow , Private data transaction flow differs in some cases. The client application sends the transaction proposal request to the only authorized endorsing peers. Then the peer invokes the request into the . Chaincode The peers analyze the private data transaction and stores in the . Then, the private data collection distributed to other authorized peers via protocol. transient data store gossip Now the endorsing peers return the proposal response to the client and the response contains the only hash of private data, it’s pair. The client doesn’t get the original private data in the response. private key-value The client submits the transaction response to the . The gets included in the block. Ordering Service hashed private data The block containing the hash of the private data is distributed to the remaining peers in the network. So the block can be validated among all the peers consistently. The authorized peers will validate their private data with the public block containing the hash of the private data. If it matches then they move the private data into the and . And then the Private data is deleted from temporary local peer storage or transient data store. Private State Database Private Writeset Storage Private Data Collection Policy As we can create collections among authorized organizations, so the collections will follow policy while instantiating the Chaincode. These policies define which organization’s peers are authorized to store the private data in their . private state database And these policies will be different from overall endorsing peer policy for a single instantiation. Chaincode In Hyperledger Fabric Go SDK, we can create a collection config for each collection and can use it while instantiating a Chaincode collCfg1, := newCollectionConfig( , , peerCount, maximumPeerCount, blockToLive)
collCfg2, := newCollectionConfig( , , peerCount, maximumPeerCount, blockToLive). _ "collectionOrg1Org2" "OR ('Org1MSP.member', 'Org2MSP.member')" _ "collectionOrg3Org4" "OR ('Org3MSP.member', 'Org4MSP.member')" Here there are two collection configs for two sets of organization groups. collCfg1 belongs only to Org1 & Org2 collCfg2 belongs only to Org3 & Org4 Function newCollectionConfig func newCollectionConfig(colName, policy string, reqPeerCount, maxPeerCount int32, blockToLive uint64) (*cb.CollectionConfig, error) {
p, := cauthdsl.FromString(policy) err != nil {
            fmt.Println( +err.Error()) nil, err
        }
        cpc := &amp;cb.CollectionPolicyConfig{ : &amp;cb.CollectionPolicyConfig_SignaturePolicy{ : p,
            },
        } &amp;cb.CollectionConfig{ : &amp;cb.CollectionConfig_StaticCollectionConfig{ : &amp;cb.StaticCollectionConfig{ :              colName, :  cpc, : reqPeerCount, :  maxPeerCount, :       blockToLive,
                },
            },
        }, nil
   } err if "failed to create newCollectionConfig : " return Payload SignaturePolicy return Payload StaticCollectionConfig Name MemberOrgsPolicy RequiredPeerCount MaximumPeerCount BlockToLive Instantiation of Chaincode While instantiating the chaincode, all the collection configs will be added into a config array. cfg := []*cb.CollectionConfig{ collCfg1, collCfg2}
policy = ccPolicy, := cauthdsl.FromString(policy) resp, := s.Resmgmt.InstantiateCC(
     s.ChannelID,
     resmgmt.InstantiateCCRequest{ :       s.ChaincodeId, :       s.ChaincodePath, :    s.ChainCodeVersion, :       [][]byte{[]byte( )}, :     ccPolicy, : cfg,
     },resmgmt.WithRetry(retry.DefaultResMgmtOpts), resmgmt.WithTargets(orgPeers[ ], orgPeers[ ])) "OR ('Org1MSP.member','Org2MSP.member','Org3MSP.member','Org4MSP.member')" // here this policy is a completely separate entity, it relates to the all organization's peers following an endorsing policy to validate all the blocks in the network consistently. _ // cauthdsl will convert the policy string to Policy object err Name Path Version Args "init" Policy CollConfig 0 1 PrivateLedger I have developed a demonstrating the using Fabric Go SDK. It’s more like an implementation of Fabric Go SDK libraries for Private data. Please follow below link below to check the project. POC Private Data Collection GitHub Github : https://github.com/Deeptiman/privateledger This project requires us to be familiar with the Multi Organization setup using Fabric Go SDK. So, If you need a reference then I have published a Medium article to describe the step by step process for the Multi Organization setup. Please have a look at it. “A Multi Organization Application in Hyperledger Fabric ” So, this is the overall description regarding the role of Hyperledger Fabric in Data Confidentiality and Privacy . I hope this article gave you some useful insight into the topic. Please find the article useful :) Thanks

Issues With Private Data and Confidentiality in Hyperledger Fabric [Deep Dive]

The Ethereum-blockchain size has exceeded 1TB, and yes, it’s an issue

While browsing Twitter I’ve noticed in protocol handler. That sounds severe. As stated in official description, for application to be vulnerable is enough to register itself as default handler for some protocol. I had one application based on Electron installed on my laptop that I was looking into some time ago — cryptocurrencies wallet. I knew that it registers itself as a handler for URI scheme. ElectronJS remote code execution vulnerability Exodus exodus:// Since no details about vulnerability were presented on the official blog post, I went straight to electron looking for recent commits. The following was a fix for vulnerability. Biggest change was a newly created file which implements few check for command line arguments. Github commit command_line_args.cc _electron - Build cross platform desktop apps with JavaScript, HTML, and CSS_github.com electron/electron Basically, the code checks command line arguments against a blacklist. Based on that, it can be assumed that it is possible to inject command line arguments via URI handler**.** Electron based applications are basically bunch of Javascript and HTML files rendered by Chromium for front-end and nodejs for back-end. And Chromium and nodejs is bundled inside main executable file. Those strings of blacklist in fix commit is command line switches for Chromium and nodejs. Seems that to exploit vulnerability we only need to find command line option in Chromium or nodejs that allows to spawn additional process. To test if it is really possible to inject arguments to Exodus.exe via protocol I created HTML file: <!doctype html><script>window.location = 'exodus://aaaaaaaaa --aaaaa='</script> Exodus wallet was launched with the following arguments. Payload was wrapped with double quotes. Nevertheless, double quote was not filtered out or sanitized before passing as command line arguments. The following allowed to inject additional command line switch. <!doctype html><script>window.location = 'exodus://aaaaaaaaa" --aaaaa=bbbb'</script> For remote code execution it is needed to find nice Chromium command line switch that allows to execute additional command. I found containing nicely summarized list of Chromium command line switches. looked promising. page gpu-launcher — gpu-launcher Extra command line options for launching the GPU process (normally used for debugging). Use like renderer-cmd-prefix. Time to try it. <!doctype html><script>window.location = 'exodus://aaaaaaaaa" --gpu-launcher="cmd" --aaaaa='</script> Exodus wallet was quick to release an update, it was released shortly after announcement of vulnerability. Also, it does a good job by pushing an update for end users by displaying messages, nevertheless update is not automatic and user still has to confirm an update. Anyway, there is ton of desktop applications based on Electron, so better check if any app running on your machine is based on Electron and make sure it is patched.

Exploiting Electron RCE in Exodus wallet

Introduction When you are writing tests for a web app, you sometimes have no other choice than to write clumsy selectors like e2e #vueRootContainer > ul > li > div Such constructions lead to code that is difficult to read and comprehend. In this article, we introduce a brand new approach that allows you to get rid of unreadable selectors and write clear and understandable test code. const todoItem = VueSelector('todo-list todo-item'); Vue.js allows you to use the component-based or declarative approach for defining web app structure. The component-based approach better fits complex applications because they need a stricter separation of concerns between the components. The team created the module — a plugin that allows you to use a component-based approach to testing Vue.js applications. This plugin enables you to select a Vue.js component by its name or a list of names. TestCafe testcafe-vue-selectors You can also access the component properties in test code. So far, TestCafe is the only framework that provides native testing experience for Vue.js applications. Let’s see how easy it is to test a Vue.js application with TestCafe. Setting Up Test Environment Installing TestCafe and testcafe-vue-selectors Since TestCafe is a pure application, its installation is simple: Node.js npm install testcafe Install the module in the same way: testcafe-vue-selectors npm install testcafe-vue-selectors Tested Application Set up the test environment to test the app from Vue.js examples. SVG Clone the Vue.js repo. git clone [http://github.com/vuejs/vue](http://github.com/vuejs/vue) 2. Install the extension for Google Chrome. Vue DevTools The description of Vue DevTools mentions two requirements: If the page uses a production/minified build of Vue.js, devtools inspection is disabled by default, so the Vue pane does not show up. To make it work for pages opened via protocol, you need to check "Allow access to file URLs" for this extension in Chrome's extension management panel. file:// Let’s address both requirements: Allow Vue DevTools to access files through the protocol. file:// 2. Substitute the production vue.js version with the development version. To do this, open and change vue/examples/svg/index.html <script src="../../dist/vue.min.js"></script> to <script src="../../dist/vue.js"></script> Now open in Google Chrome and activate Vue DevTools. If everything was done right, following picture displays: vue/examples/svg/index.html Testing the application Page Object Let’s explore the application component structure. The page contains a polygraph component with six AxisLabel children. Next, define the based on this structure. Page Object Since the form for adding a new stat is defined with a declarative approach, we use built-in TestCafe selectors. For details about TestCafe selectors, see . Selectors Stats painted on the graph are defined with a component-based approach, and we use VueSelector for them. For more information about VueSelector, see . testcafe-vue-selectors Create folder and save the Page Object definition to the file. Later on, we will import this file as a regular module. testcafe page-object.js Test Scenario Actions, assertions, and the file protocol Let’s create the file and put it into the directory. TestCafe supports the protocol, so you do not need to set up a local HTTP server to run the tests. All you need is specify the path to the tested page as a target page URL. svg-test.js testcafe file:// The test scenario adds a new stat labeled and checks that the number of stats changed from 6 to 7. G This code uses methods that emulate user actions: and . You can find more details about actions in the documentation topic. typeText click Actions We use built-in assertions to check that the HTML elements’ properties have the expected values. They expose various methods to compare values and provide the . For details on assertions, see . Smart Assertion Query Mechanism Assertions Since inherits from , you can use all the capabilities of TestCafe selectors. For instance, the code above uses the property from the Selector API. VueSelector Selector count Component state and properties The plugin also allows you to obtain Vue.js component properties. Extend the test above with code that verifies the added stat's properties: testcafe-vue-selectors This code uses the method to obtain the Vue component's properties. This method returns an object that contains the , and properties. You can find detailed information in the repository. getVue() props state computed [testcafe-vue-selectors](https://github.com/devexpress/testcafe-vue-selectors) Running Tests Create a new file and add a test run command to it.: package.json {"scripts": {"test": "testcafe chrome testcafe/svg-test.js"}} Now you are ready to run your first test. Type in your console: npm test After that, TestCafe launches the Google Chrome browser, executes the test scenario, closes the browser, and outputs the result to the console. TestCafe allows you to run tests in locally installed browsers, on mobile devices, and in cloud testing platforms. For detailed information, see . Browser Support You can also choose the format in which test run reports are presented: spec, list, minimal, xUnit and JSON formats are available out of the box. See for more information. Reporters Conclusion In this article, we learned how to test a Vue.js application. As an example, we used the SVG app from the Vue.js repository. We covered setting the test environment, creating tests, running and viewing test results. If you have questions, visit our . If you want to report an issue or submit a suggestion, go to the and repositories. forum TestCafe testcafe-vue-selectors

A modern way to do E2E testing for Vue.js apps

Throughout my career, I have primarily focused on developing backend systems using . Despite dabbling in front-end work, I always found myself gravitating back toward development. In order to expand my skill set, I have experimented with writing backend applications using different programming languages such as JavaScript/Typescript and Rust. I have tested various technologies and frameworks, some of which I found more enjoyable than others. Nonetheless, there remains one language that I have yet to explore: Python API Go. When I first started using Golang, it felt a little unfamiliar due to its simplicity, unique error handling, and some unusual design choices like struct tags. However, even before getting fully accustomed to these "quirks", I quickly realized several things about Go that I genuinely appreciate. Interestingly, these same features can be seen as challenges in my primary programming language, Python. In this article, I will share my initial thoughts on using Go as a Python engineer. I will highlight the aspects of Go that I appreciate, which may not be as prominent in Python. These include: built-in tools packaging backend focus setting up Docker performance By the end of this article, you will understand why Go is an excellent option for backend applications and how it compares to Python in terms of convenience. Tooling When it comes to building software, the main task is writing code. However, there are several potential problems that can arise during this process. These can include: incorrect formatting bugs common code issues As engineers and humans, it's impossible to guarantee that our work is completely flawless. This is where automated tools like linters, unit tests, and static analysis can be incredibly useful in providing additional assistance. When working with Python, formatting can be a challenge. While the most popular tool for formatting is , it requires installation and configuration. However, configuration can be difficult as there are multiple ways to do it, with being the default option according to , but not all tools support it. black pyproject.toml PEP 518 In terms of linting, prior to the release of in 2022, Python developers had to rely on and its various plugins, which were inconvenient to configure. Thankfully, now supports many features and can be configured via the file. ruff flake8 ruff pyproject.toml Similarly, if you want more powerful testing capabilities than what is offered by the built-in , you'll need to install and configure additional tools and addons. It's important to ensure that all of these components work together properly in your CI system as well. unittest When working with Go, the development experience can be quite different. Upon installation, you will have access to a wide range of tools to aid your local development. Compared to Python, formatting rules in Go are less strict. For example, there is no fixed line length. However, Go has a built-in formatting tool that can be accessed through the command, eliminating the need for additional installation or configuration. go fmt Another useful tool in Go is the command, which helps to identify common coding mistakes such as unreachable code or useless comparisons. In addition, external linters like can be used to detect bugs and performance issues with ease. go vet staticcheck For testing purposes, Go provides a command that automatically discovers tests within your application and supports features such as caching and code coverage. However, if you require more advanced testing capabilities such as suites or mocking, you will need to install a toolkit like . Overall, while Go provides a highly effective testing experience, it's worth noting that writing tests in Python using is arguably one of the most enjoyable testing experiences I have encountered across all programming languages. go test testify pytest It's also important to remember that there's no need to use type-checking tools such as with Go, as it's a compiled and statically-typed language. mypy In summary, once you've installed Go, you'll have access to the necessary tools to support your code-writing efforts. The next step is to focus on packaging and managing dependencies. Packaging Managing dependencies is crucial when building software. While Golang has an extensive standard library, more complex projects often require external packages. Luckily, Go provides excellent tools for effectively managing dependencies. Go projects come with two files: and . The file is particularly crucial as it lists all the direct and indirect dependencies along with their versions. The file is automatically generated to serve as a checksum of the dependencies. go.mod go.sum go.mod go.sum To install a package, you use the command. The good news is that this command saves the installed packages in the directory, so there is no need to manually create virtual environments or similar things. go get <package> $GOPATH/pkg/mod In addition, you can use the command to ensure consistency between the file and the source code in the module. This command will add any missing module requirements needed to build the current module's packages and dependencies. If there are any unused dependencies, will remove them from . go mod tidy go.mod go mod tidy go.mod Finally, publishing packages with Go is incredibly simple. To install them, you typically just need to use the repository link, such as . So, to publish your own package, all you have to do is properly set up your module in the file, create a public repository, and request the package at . After a short period of time, your package will be available in the Go module index. That's it. go get github.com/tobias-piotr/gouth0 go.mod https://pkg.go.dev/ Now compare this with Python. By default, Python doesn't even have a checksum file. If you want more advanced features, you'll need to install a tool like , which has many external dependencies. Managing project dependencies can be done through a file, but you'll need to create and maintain it yourself. Compared to Go, publishing packages to PyPI can also feel inconvenient. poetry Without further criticism of Python packaging, Go's packaging feels much simpler and more convenient. The next chapter will cover how Go's setup is beneficial when working with Docker. Docker When it comes to building web applications in the modern world, Docker is usually involved. It simplifies the process of setting up a project locally and deploying it to production. Creating a Dockerfile for a Golang project is remarkably easy for two primary reasons: the Go tooling mentioned earlier and the fact that Go is a compiled language. Additionally, the combination of these two factors leads to a very standardized method of setting up a project. This means that if you copy a Dockerfile from one Golang project to another, there is a high probability that it will work without any issues. This is quite different from the situation in Python. With all of this in mind, take a look at a Dockerfile from one of my Go projects: FROM golang:1.20.6-alpine AS builder

EXPOSE 8080

WORKDIR /app

COPY go.mod go.sum ./
RUN go mod download

COPY . .

RUN CGO_ENABLED=0 GOOS=linux go build -o /main

# Local development
FROM builder as dev

ENV DEBUG=true

# Install air for hot reloading
RUN go install github.com/cosmtrek/air@latest

ENTRYPOINT ["air"]

# Production
FROM gcr.io/distroless/base-debian11 AS prod

WORKDIR /

COPY --from=builder /main /main

USER nonroot:nonroot

ENTRYPOINT ["/main"] Without diving too deep into the Docker syntax, this config simply downloads dependencies, compiles code, and runs the binary file. It's important to note that Go, being a compiled language, improves this process. For example, you can use a tool like to use the binary file and enable hot reloading while developing locally. Additionally, in production, a smaller base image can be used because no OS dependencies are required to start the binary file. This significantly reduces the image size of your app. air Starting a new project in Go is great because it's easy to set up a fully working and optimized Dockerfile. With tooling, packaging, and containerizing covered, we can finally focus on the language's features. Backend Focus When I first started working with Go, I had doubts about its suitability for backend development. However, it didn't take long for me to realize that Go is actually designed with backend development in mind. One of the main things that make Go well-suited for backend development is its standard library. This library includes a variety of useful packages for tasks such as encoding, cryptography, and database management. Most importantly, it also includes packages for building HTTP servers, which means you can create a semi-sophisticated API without needing to install any additional dependencies. For instance, I was able to develop an authentication API for interacting with Auth0 using just one external package (for structured logging). You can view the code here: . goloxy On top of that, there are many amazing packages available for developing web applications, including: web frameworks: Gin, Fiber, chi, Echo validation: validate, ozzo-validation, Valgo structured logging: zap, logrus, zerolog database interactions: GORM, sqlx, sqlc, Ent My preferred combination is Echo/chi as a web framework, Valgo for validation, zap for structured logging, sqlx for database interactions, and Fx for dependency injection. This setup has been effective for most of my projects, though it may vary depending on specific requirements. To highlight a difference with Python, configuring structured logging can be a challenge, even with a great framework like FastAPI. In an Echo app, I configure the zap logger in the following way: e.Use(middleware.RequestLoggerWithConfig(middleware.RequestLoggerConfig{
	LogProtocol:  true,
	LogMethod:    true,
	LogURI:       true,
	LogStatus:    true,
	LogRequestID: true,
	LogRemoteIP:  true,
	LogLatency:   true,
	LogError:     true,
	LogValuesFunc: func(c echo.Context, v middleware.RequestLoggerValues) error {
		logger.Info(
			fmt.Sprintf("%s %s %s %v", v.Protocol, v.Method, v.URI, status),
			zap.String("protocol", v.Protocol),
			zap.String("method", v.Method),
			zap.String("uri", v.URI),
			zap.Int("status", status),
			zap.String("request_id", v.RequestID),
			zap.String("remote_ip", v.RemoteIP),
			zap.String("latency", v.Latency.String()),
			zap.Error(v.Error),
		)
		return nil
	},
})) In addition to creating a logger instance, which is usually just a few lines, this is all that is required to have complete control over the logger for each request. An example of setting up structured logging in a FastAPI app can be found using the package here: (adding it between the backticks, because it is way too long to be embedded). This is surely overwhelming, even when you are fully aware of what's going on there. structlog https://gist.github.com/nymous/f138c7f06062b7c43c060bf03759c29e To summarize, Go has excellent built-in and externally installable solutions for developing web apps. However, implementation is just the beginning. The next chapter will cover the performance of Golang code. Performance When examining the most popular uses of Go, examples include proxies, infrastructure management, and "typical" web development. One of the reasons for its popularity is the exceptional performance of Go, especially when compared to Python, which is known to have weaker performance. There are numerous factors that contribute to Go's superior performance. such as: lightweight design, which reduces runtime overhead efficient garbage collection impressive concurrency model with Goroutines strong typing and static analysis These are just a few examples of the reasons why Go is so well-performing. All of these features enable the creation of highly optimized applications that can efficiently handle large workloads and easily scale even further. It's possible that one might argue that performance isn't crucial in many applications. In such cases, you could simply select Python, take code from a previous FastAPI project, base it around asyncio, and it should perform well enough. This argument may be valid. However, performance isn't just about speed; it also relates to resources. You might not notice speed differences when comparing an app written in Golang to one in Python - the differences are in nanoseconds. However, you will definitely see the difference in resource usage. The app developed in Go will use significantly fewer resources. This will be evident through lower costs. I recommend watching where he explains how rewriting a SAAS project in Go resulted in reduced costs. Ben Davis' video When it comes to performance, Python doesn't have the best reputation. This is largely due to the GIL, dynamic typing, and awkward concurrency model. While there are optimizations available, such problems are less frequent in Go. Therefore, when prioritizing performance, Go may be the better option. Summary Based on my experience with various technologies, I have some personal favorites. However, when building software, it is important to consider multiple factors before choosing the best tech stack. For backend development, Go stands out as an excellent option, especially when performance and cost are crucial. Nevertheless, it's not without any flaws. I believe that in modern Python, FastAPI and Pydantic are its strongest features for web development. They offer features like dependency injection, Swagger documentation, exceptional validation, and error handling right out of the box. I also find pytest to be the most well-designed test writing tool I've encountered. In summary, Go lacks some of the drawbacks that Python has, but Python has a wealth of features and libraries for app development. Ultimately, it depends on your specific needs and trade-offs. Also published here.

Gopher Pythonista #1: Transitioning from Python to Go

Those who do not learn history are doomed to repeat it. Unfamiliar with the term ? Gmail, Yahoo, and every other company you know in the email market are all clients built on the SMTP or IMAP email protocol. The client is an interface, and the Protocol connects all the interfaces. For example, Twitter is a client with a database, but it could be one of many interfaces connected through a protocol. Protocol I’m writing this article to explain why I have decided to build an audience on a niche social platform known as Warpcast, a client of the Farcaster Protocol, “ .” A protocol for building sufficiently decentralized social networks The Protocol is being developed by a team of former Coinbase staff, and it leans heavily into encryption, decentralization, ownable identity, and despite all odds, an extremely scalable, durable, and fast social data store growing in decentralization. Why is that important? Let us start by looking not at the team, the features, or the promise; but at the investors who support it. https://twitter.com/elonmusk/status/1520949176103620608?s=20&embedable=true Is it starting to make sense yet? Innovation does not all stem from a single company, and it is not likely to arise from the failed choices and leadership of a bellied-up company like Twitter/Bluesky. That is why I bet on the Farcaster protocol, to reap the benefits of being an early adopter of what may be the backbone of all future social media. As an early adopter, developer, content creator, reader, and outside founder, I need neither laundry nor food. My long-term goals point to the set of opportunities that the Farcaster team worked hard to unlock. I need access, I need high-status networks, I need intense technical discussion, I need technologists, and I need the most easily accessible distribution channels that a man can find. I need work opportunities, money in my pocket, introductions to people, and referrals that I could not otherwise obtain. Is it starting to make sense? Protocol, client, opportunities. I was drawn towards Farcaster because joining closely resembled my approach towards startups; it was . Even though my business wasn't directly related to social media, I aimed to and . By tapping into these new networks, I found everything and more. Opportunities like this enabled today's mega-influencers like DJ Khaled, Gary Vee, Jamie Oliver, and countless brands to become known yesterday. The opportunity is unmatched when compared to growing on an existing network, and the pie is getting larger. high risk yet held the potential for high reward expand my network build product distribution channels https://youtu.be/mArnxXgyeQQ?embedable=true I found a job in data engineering I found $10,000+ (6.9Ξ (Ethereum)) to build whatever I wanted I found referrals, mentors, and friends I became a better developer and engineer I learned why my Startup would fail and what could win I learned what people do in their startup careers and who they were I watched my friends raise hundreds of thousands, even millions I watched artists, writers, and developers earn cash for work I participated in a DAO war; unfolding realtime The Great Online Game I watched Vitalik pretend to care about decentralizing social media …99. https://github.com/farcasterxyz/protocol?embedable=true Understanding Turing Completeness . Although I know it relates to the Turing test, which signifies a system's capability to perform any computational task, relating the meaning to specific circumstances remains difficult. This concept frequently surfaces in discussions around programming languages and blockchains. However, regarding its application in a Social Network protocol, the discourse is still in its early stages and somewhat primitive. Turing completeness is a term that often leaves me perplexed handles many schemas, including standard text content, unique metadata (such as links, blockchain transactions, nft items, etc.), reactions, polls for voting, and any novel proposals. Generic message type , such as Reddit communities, or the unique audiences on otherwise completely separate platforms such as Twitter, LinkedIn, Instagram, or TwitchTV. Social Contextualization and the prioritization of new content (say one year old), with the ability to form markets around longer-term access and memory. Rapid yet decentralized storage , meaning true encryption, where the CEO can’t unlock the data with their encryption key. This applies to private messages and content publicly available in the social feed. Encrypted content , similar to Ethereum sign-in and Social Logins like Facebook or Google, these Identity solutions can offer key advantages such as the type of data packaged on a signature, access controls, and decentralization (existence beyond a single company) Identity Solutions Unlocking Opportunity Today Why would anyone care about a Turing-complete and decentralized social Protocol? If you read the section above and it did not resonate, let’s sideline the entire conversation and focus on the immediate value propositions of a new social network. applies to startups, social experiences, job opportunities, and any place where the ability to start anew is akin to firing a cold engine; it’s difficult and requires priming. The Cold Start Problem That is a problem for the founders, and it’s a problem they’ve worked hard to overcome. It is not a problem for users, Farcaster may have a capped volume to date, but what it lacks in quantity, it makes up in quality, whether that is the willingness to engage new users, the reach and activity generated by an otherwise average performing post, or the excitement generated by high achieving content. I would compare the activity generated by 100 users on Farcaster to 1,000+ on Twitter or similar socials. That is not to say they mindlessly like content; genuine interactions are as simple as liking a post or sharing it to as complex as helping onboard new users and funneling monetary value into the content through NFT purchases and new business lead generation. Farcaster This is the only Social Network I have joined which returned more than $10,000, or 6.9Ξ (Ethereum), within a few months of attempting it and under a year since joining the network- . all this with no prior connections to anyone on the network https://twitter.com/JoshuaOgundu/status/1200443772858847232?s=20&embedable=true To me, friendship is a willingness to help others, including without any immediate benefit. I see it as less transactional than was offered up by my friends in Tech but not wholly lacking. I have met many interesting people on Farcaster, and like my experience in Founding, I have made friends with whom I have never met in the real world. I find this less outlandish than some, and I value real-world interaction. I am simply limited and play by the rules of the game. I refer to , the ability to perceive the internet as we know it as an incarnation of the Metaverse in a text-based format, an with real-world consequences, opportunity, friendship, and love. Farcaster is a new land, vast with opportunity, products, and people, yet mostly unknown. The Great Online Game MMORPG It has player groups, specifically in the spirit of web3, DAOs. One of the most notable is the which recently went into a spirited battle with a competing ; the funny thing is, they are competing to give away money to new creators and builders to help foster the Farcaster ecosystem; they’re simply competing on the best way to achieve that. These opportunities include developers, artists, gamers, writers, founders, etc. Even my article is part of a native community-led ( ) contest. Purple DAO Purpler DAO not founder-led I've also witnessed the launch of , a web3 style startup that emerged from the Farcaster community. Although it is currently small in scale, it has attracted exceptional builders and founders, including notable figures such as of Lens and Aave, from Coinbase's new L2 project coined base, , the creator of the revolutionary decentralized compute platform Quilibrium, , the founder of Farcaster, and , an impressive young builder who is now an ENS employee. These individuals and many other startup founders and employees have shared their insights and experiences through interviews, demonstrating their resilience during a global economic recession and a crypto bear market. unlonely.app Twitch.tv Stani Kulechov Jesse Pollak @Cassie Dan Romero Greg Skriloff https://www.unlonely.app/nfc/327?embedable=true Other remarkable people are working on projects like decentralized hacker news , interoperable crowdfunding , NFT trading with , and zero-knowledge social technologies with . The presence of these accomplished individuals and their contributions further enriches the vibrant web3 startup ecosystem on Farcaster. kiwinews.xyz withfabric.xyz VFProtocol bigwhalelabs Joining the Farcaster Network I joined Farcaster for apparent reasons; after exploring many new and existing social platforms, I decided the best opportunity was to build an audience through the largest opportunity platform. One that allowed me to readily discuss my interests, specifically startups, web3, metaverse, and identity. It enables me to bootstrap distribution to a group of individuals within those niches. And it allows me to grow with the platform, which would have been incredibly hard on other platforms if compared to aged accounts that have bootstrapped growth for years. I have about 1,500 followers, around 15% of the total network, a network with almost no bots, and an otherwise rigorous and hand-vetted invite process. Only now is that invite system starting to open up slowly. You can reach many well-known people and people just starting out; seriously, it’s all about the people. Simply familiarizing myself with the technologies helped me obtain new job opportunities, access references, and build a professional network to learn from that would have otherwise likely not been possible. Not everyone posts about web3 or Ethereum, and new content is welcomed. From Marc Andreessen shilling communism upon unsuspecting capitalists To Vitalik, cosplaying as someone who might have known how to build deep neural networks and Brian Armstrong teaching us about the value of friendship Farcaster is the place I chose to double down on, where I meet friends, engage in combat, share new ideas, complain about the founders, and ultimately, where I hope to become rich and famous through (jk). But, in the infamous words of Mister Rogers’ Neighborhood, ? Won't You Be My Neighbor Want to Join? I currently have 48 invites and would like to use them to bring new members into the community. To acquire an invite, comment on this article, or email me directly at padenfool[@]gmail[.com]. As for me, I’ll be busy working on a new career, a career which was unlocked through… you guessed it, the Farcaster Protocol! -Alex https://youtu.be/nNPKiD7p4XM?embedable=true

Stories, News & Mentions about VIAPROTOCOL

Viaprotocol’s Stories on HackerNoon