Dutch-born Ghanaian defender Mitch Apau has earned a well-deserved spot in Sofascore's Eerste Divisie Team of the Week following a standout performance.The 33-year-old showcased his prowess by scoring the decisive goal in Telstar's recent triumph over TOP Oss in the Eerste Divisie.

Ghanaian defender Mitch Apau's late heroics earns him Team of The Week spot

Friday night's meeting of Leicester City and Leeds United brings together the Championship's top two and that is not the slight on Ipswich Town you might think it is.

Leeds United and Leicester City meeting brings clash of Championship's agent-sharing 'big two'

Manchester United trio of Andre Onana, Diogo Dalot and Harry Maguire have all been named in Sofascore’s UEFA Champions League Team of the Week. The three were included in the star-studded team for their valuable contributions during United’s dramatic 1-0 win against FC Copenhagen at Old Trafford on Tuesday.

Heroic Manchester United trio named in Champions League Team of the Week | OneFootball

Heroic Manchester United trio named in Champions League Team of the Week

The player with the joint worst match rating of any starting player on the Leeds side (6.4/10), even lower than that man Bamford (6.5) - as per SofaScore - it was no surprise to see him hooked in the 70th minute, especially after making just 38 touches in ...

Leeds dud who lost possession 13x was worse than Bamford vs Stoke

Newcastle United were dealt a blow in the Champions League against Borussia Dortmund, with a host of stars far from their best on the

Newcastle ace who was "not at his best" was as bad as Longstaff vs Dortmund

Gabriel Jesus was Arsenal's star man during their victory over Sevilla, however one star was just as good as the

Arsenal: Arteta's "sensational" dynamo stole the show vs Sevilla alongside Jesus

Ghanaian winger Prince Ampem has earned recognition in Sofascore's Turkish Trendyol 1. Lig team of the week for his outstanding performance against Corum FK.The former West African Football Academy (WAFA) attacker played a crucial role in Eyupspor's 3-2 away win against Corum FK in the

Ghanaian forward Prince Ampem earns spot in Turkish Trendyol 1. Lig TOTW

As per Sofascore, Bogusz played 90 minutes in central midfield and caught the eye with a pass completion rate of 82% and one chance created, along with a 100% dribble success rate (1/1). The Polish whiz also displayed his defensive strength with six out of ...

Leeds: Orta's £900k sale has more goals and assists than Gnonto this year

Modernghana Sports partner, SofaScore has put together the latest list of top 10 highest-rated Ghanaian Players Abroad.

Prince Ampem, Baba Rahman & Issahaku among Top 10 highest-rated Ghanaian Players Abroad

Sofascore

sofascore

What you will be building, see our for the finished work and our . git repo live demo Introduction Welcome to our comprehensive guide on "Building a Web3 Play-To-Earn Platform with Next.js, Typescript, and Solidity". In this tutorial, we'll build a decentralized Play-To-Earn platform that leverages the power of blockchain technology. You'll gain a clear understanding of the following: Building dynamic interfaces with Next.js Crafting Ethereum smart contracts with Solidity Incorporating static type checking using TypeScript Deploying and interacting with your smart contracts Understanding the fundamentals of blockchain-based Play-To-Earn platforms By the end of this guide, you'll have a functioning decentralized platform where users can participate in Play-To-Earn games, with all activities managed and secured by Ethereum smart contracts. As an added incentive for participating in this tutorial, we're giving away a copy of our prestigious book on becoming an in-demand Solidity developer. This offer is free for the first 300 participants. For instructions on how to claim your copy, please watch the short video below. Prerequisites You will need the following tools installed to build along with me: Node.js Yarn Git Bash MetaMask Next.js Solidity Redux Toolkit Tailwind CSS To set up MetaMask for this tutorial, please watch the instructional video below: https://www.youtube.com/watch?v=qV1mbFOtkxo&embedable=true Once you have successfully completed the setup, you are eligible to receive a free copy of our book. To claim your book, . please fill out the form to submit your proof-of-work With that said, let’s jump into the tutorial and set up our project. Setup We'll start by cloning a prepared frontend repository and setting up the environment variables. Run the following commands: git clone https://github.com/Daltonic/play2earnX
cd play2earnX
yarn install
git checkout 01_no_redux Next, create a file at the root of the project and include the following keys: .env NEXT_PUBLIC_RPC_URL=http://127.0.0.1:8545
NEXT_PUBLIC_ALCHEMY_ID=<YOUR_ALCHEMY_PROJECT_ID>
NEXT_PUBLIC_PROJECT_ID=<WALLET_CONNECT_PROJECT_ID>
NEXTAUTH_URL=http://localhost:3000
NEXTAUTH_SECRET=somereallysecretsecret Replace and with your respective project IDs. <YOUR_ALCHEMY_PROJECT_ID> <WALLET_CONNECT_PROJECT_ID> : YOUR_ALCHEMY_PROJECT_ID Get Key Here : WALLET_CONNECT_PROJECT_ID Get Key Here Finally, run to start the project. yarn dev Our user interface is prepared to incorporate smart contracts, however, we still need to integrate Redux in order to facilitate the sharing of data. Building the Redux Store The above image represents the structure of our Redux store, it will be simple since we are not creating some overly complex project. We'll set up Redux to manage our application's global state. Follow these steps: Create a folder at the project root. store Inside , create two folders: and . store actions states Inside , create a file. states globalStates.ts https://gist.github.com/Daltonic/f542e5769c9f9f92009c0ab97e26ffe0?embedable=true Inside , create a file. actions globalActions.ts https://gist.github.com/Daltonic/9d5487e2e3f2517b36a1a38805e5c989?embedable=true Create a file inside the folder. globalSlices.ts store https://gist.github.com/Daltonic/0af23b96f972b0f3a934c4a26b90286d?embedable=true Create an file inside the folder. index.ts store https://gist.github.com/Daltonic/7b7ec88441e0b03b3c11ada05aa49104?embedable=true Update the file with the Redux provider. pages/_app.tsx https://gist.github.com/Daltonic/b13c27143cfd13d5e2949a8e530f160d?embedable=true We have implemented Redux toolkit in our application and plan to revisit its usage when integrating the backend with the frontend. Smart Contract Development Next, we'll develop the smart contract for our platform: Create a folder at the project root. contracts Inside , create a file and add the contract code below. contracts PlayToEarnX.sol https://gist.github.com/Daltonic/4543f76e6a0731a8795f618248d663da?embedable=true The above smart contract is a Play-To-Earn (P2E) gaming platform, which is created with Solidity. The contract integrates features such as game creation, player invitations, score recording, and payout distribution. Here's a breakdown of its logic, function by function: This function initializes the contract. It sets the service fee percentage and assigns initial token parameters. Constructor ( constructor(uint256 _pct) ERC20('Play To Earn', 'P2E') ): This function allows a user to create a new game, specifying the title, description, number of participants, number of winners, start date, and end date. It requires a stake greater than zero and validates all input data. A new game and score structure are created and stored in their respective mappings. createGame Function: This function allows the owner of a game to delete it, provided no participants have joined. It refunds the stake to the game owner and marks the game as deleted. deleteGame Function: This function is an internal function that creates a new player for a game. It increments the total players count, adds the new player to the players mapping, and increases the game's acceptees count. playedSaved Function: This function allows a user to invite another player to a game. It checks if the game exists and if there is room for more players. An invitation is then created and added to the invitationsOf mapping. invitePlayer Function: This function allows a user to accept an invitation to a game, provided they send enough funds to cover the game's stake. It creates a new player for the game and updates the invitation status. acceptInvitation Function: This function allows a user to reject an invitation. rejectInvitation Function: This function handles the payout distribution at the end of a game. It checks if the game has ended and if it has not already been paid out. It calculates the total stakes, platform fee, creator fee, and game revenue. It pays out the platform fee to the contract owner, the creator fee to the game owner, and distributes the game revenue among the winners. It also mints new tokens for the winners. payout Function: This function sorts players based on their scores. It uses a simple bubble sort algorithm with a twist: it also takes into account whether a player has played the game or not. Players who have not played are sorted to the bottom. sortScores Function: This function allows a player to save their score for a game. It validates the game and player, then updates the player's score. saveScore Function: This function allows the contract owner to change the service fee percentage. setFeePercent Function: These functions return lists of games based on different criteria (all games, games that have been paid out, and games owned by the caller). getGames, getPaidOutGames, getMyGames Functions: This function returns the details of a specific game. getGame Function: This function returns all invitations for a specific game. getInvitations Function: This function returns all invitations received by the caller. getMyInvitations Function: This function returns all scores for a specific game. getScores Function: This internal function sends funds to a specified address. payTo Function: This internal function returns the current timestamp. currentTime Function: Contract Deployment and Seeding Now, let's deploy our smart contract and populate it with some dummy data: Create a folder at the project root. scripts Inside , create a and a file and add the following codes. scripts deploy.js seed.js Deploy Script https://gist.github.com/Daltonic/de4cb519cefa6baa8d3b2d37b24c6afd?embedable=true Seed https://gist.github.com/Daltonic/723ba48f1f3c7fdac38225afc5eb3466?embedable=true Run the following commands to deploy the contract and seed it with data: yarn hardhat node # Run in terminal 1 yarn hardhat run scripts/deploy.js # Run in terminal 2 yarn hardhat run scripts/seed.js # Run in terminal 2 If you did that correctly, you should see a similar output like the one below: At this point we can start the integration of our smart contract to our frontend. https://www.youtube.com/watch?v=fJIiqeevqoU&embedable=true Frontend Integration First, create a folder at the project root, and inside it, create a file. This file will contain functions to interact with our smart contract. services blockchain.tsx https://gist.github.com/Daltonic/1a1fc8d33d508ea39a8bdc640a3072ec?embedable=true The above code is a service that interacts with our Play-To-Earn gaming smart contract on the chain. It uses the library to interact with the Ethereum blockchain for contract interaction. Ethers.js Here's a detailed breakdown of its functions: This function sets up a connection to the Ethereum blockchain and the smart contract. It uses the ethers library to create a provider (to interact with the Ethereum blockchain) and a signer (to sign transactions). Then, it creates a contract instance that can be used to interact with the smart contract. getEthereumContracts Function: This function retrieves the owner of the contract. It calls the owner function of the contract, which is defined in the OpenZeppelin's Ownable contract. getOwner Function: These functions retrieve information about the games. They call the corresponding functions in the contract and structure the returned data. getGames, getMyGames, getGame Functions: These functions retrieve information about the game invitations. They call the corresponding functions in the contract and structure the returned data. getInvitations, getMyInvitations Functions: This function retrieves scores of a game. It calls the corresponding function in the contract and structures the returned data. getScores Function: This function creates a new game by calling the createGame function of the contract. It checks if the browser provider is installed and handles any errors that might occur. createGame Function: This function deletes a game by calling the deleteGame function of the contract. It checks if the browser provider is installed and handles any errors that might occur. deleteGame Function: This function invites a player to a game by calling the invitePlayer function of the contract. It checks if the browser provider is installed and handles any errors that might occur. invitePlayer Function: This function saves a player's score by calling the saveScore function of the contract. It checks if the browser provider is installed and handles any errors that might occur. saveScore Function: This function handles payout distribution by calling the payout function of the contract. It checks if the browser provider is installed and handles any errors that might occur. payout Function: This function allows a user to respond to an invitation by calling either the acceptInvitation or rejectInvitation function of the contract, based on the user's response. It checks if the browser provider is installed and handles any errors that might occur. respondToInvite Function: These functions structure the data returned from the contract into a more manageable format. They convert the data types from the contract's format to JavaScript's format and sort the data. structuredGames, structuredInvitations, structuredScores Functions: Next, update the file inside to include the network using the following codes. provider.tsx services bitfinity https://gist.github.com/Daltonic/5cfe4e97fe6d258a256f76c46cb7beaa?embedable=true Page Interacting with Smart Contract Next, we'll link the functions in the blockchain service to their respective interfaces in the frontend: Update to get data from the function. No 1:  Displaying Available Games pages/index.tsx getGames() https://gist.github.com/Daltonic/c275c2e007ad1d8ca56c2b5adc5f21c3?embedable=true Update to get data from the function. No 2:  Displaying User’s Games pages/games.tsx getMyGames() https://gist.github.com/Daltonic/c0226ed85d75fb5c1ea39909ab692b05?embedable=true Notice how we combined to dispatch the games into the store before rendering on screen. useEffect() Update to get data from the function. No 3:  Displaying User’s Invitations pages/invitations.tsx getMyInvitations() https://gist.github.com/Daltonic/d10d5dca4d8c8d7423345bbd39e83cbc?embedable=true We also combined to dispatch the invitations into the store before rendering on screen. useEffect() Update to use the , , and to retrieve a game invitations by specifying the game Id. No 4: Displaying Game Invitations pages/invitations/[id].tsx getServerSideProps() getGame() getInvitations() https://gist.github.com/Daltonic/232c8a64779ababf873a3e94e609b11d?embedable=true Update to use the , , and to retrieve a game players by specifying the game Id. No 5: Showcasing a Gameplay pages/gameplay/[id].tsx getServerSideProps() getGame() getScores() https://gist.github.com/Daltonic/fb73e1ed6f11043a5e63a6df903392ed?embedable=true The script mentioned above is the core of the frontend code for this page. It contains the necessary functions and behaviors to create a memory game where users can compete against each other. Update to use the , , and to retrieve a game score by specifying the game Id. No 6: Displaying Game Result pages/results/[id].tsx getServerSideProps() getGame() getScores() https://gist.github.com/Daltonic/e448bc7e13356314d7e7169dfd5d43ad?embedable=true It's worth mentioning that users can make a payout from this page after the game duration has ended. Components with Smart Contract Let's apply the same approach we used for the previous pages and update the following components to interact with the smart contract. Update file to use the function to call the function for form submission. No 1: Creating New Games components/CreateGame.tsx handleGameCreation() createGame() https://gist.github.com/Daltonic/6106948a6b3d49896ec1bb6847b51bad?embedable=true Update file to use the function to call the function. No 2: Handling Game Deletion components/GameActions.tsx handleDelete() deleteGame() https://gist.github.com/Daltonic/593b697b274e0fab608801bbc7e5515f?embedable=true Update file to use the function to call the function. No 3: Displaying Game Details Modal components/GameDetails.tsx closeModal() setResultModal() https://gist.github.com/Daltonic/f89025c44a207a710cf04ac79515d9dd?embedable=true Update file to use the function to call the function. No 4: Inviting Players components/GameInvitation.tsx handleResponse() respondToInvite() https://gist.github.com/Daltonic/4405f7b64b34177e6be707d29301ab25?embedable=true Update file to use the function to call the function. No 5: Launching Game Details Modal components/GameList.tsx openModal() setResultModal() https://gist.github.com/Daltonic/877971532ffa1a1e364bc1fb8ba03234?embedable=true Please note that this function actually launches the game details modal, that’s a little oversight in function name. setResultModal() Update file to the function, this will help us launch the create game form modal. No 6: Launching the Create Game Modal components/Hero.tsx dispatch setCreateModal() https://gist.github.com/Daltonic/cb1c9ee1024f9219a9813fc261d4befd?embedable=true Lastly, update file to use the function to call the function. No 7: Launching the Invite Modal components/InviteModal.tsx sendInvitation() invitePlayer() https://gist.github.com/Daltonic/6ca046aef2762c32a7c382b9c648d29f?embedable=true The project is now complete as all components and pages are connected to the smart contract through the implementation of these updates. If your Next.js server was offline, you can bring it back up by executing the command . yarn dev For further learning, we recommends watch the full video of this build on our and . YouTube channel visiting our website for additional resources https://www.youtube.com/watch?v=zi_6RWkOB1w&embedable=true Conclusion In this tutorial, we've successfully built a decentralized Play-To-Earn platform using Next.js, TypeScript, and Solidity. We've established the development environment, constructed the Redux store, and deployed our smart contract to our local chain. By merging the smart contract with the frontend, we've ensured a seamless gaming experience. This guide has equipped you with the skills to create dynamic interfaces, craft Ethereum smart contracts, manage shared data with Redux, and interact with smart contracts from the frontend. Now, you're ready to create your own Web3 Play-To-Earn platform. Happy coding! About Author I am a web3 developer and the founder of Dapp Mentors, a company that helps businesses and individuals build and launch decentralized applications. I have over 7 years of experience in the software industry, and I am passionate about using blockchain technology to create new and innovative applications. I run a where I share tutorials and tips on web3 development, and I regularly post articles online about the latest trends in the blockchain space. YouTube channel called Dapp Mentors Stay connected with us, join communities on Discord: Join X-Twitter: Follow LinkedIn: Connect GitHub: Explore Website: Visit

How to Build a Web3 Play-To-Earn Platform with Next.js, Typescript, and Solidity

Looks like it’s part 2 of my series on Data Quality! In a , I explored Airbnb’s strategy for enhancing data quality through incentives. They implemented a single score and clear scoring criteria to establish a common understanding between data producers and consumers, fostering a genuine sense of ownership. previous post https://hackernoon.com/data-quality-score-one-score-to-rule-them-all?embedable=true Now, Lyft is taking a distinct approach, not attempting the same thing differently, but rather focusing on different aspects of data quality. And, Lyft’s strategy complements Airbnb’s efforts. While I regard Airbnb’s DQ score (or any similar score) as an effective means to consolidate various attempts at elevating data quality, Lyft is tackling this challenge from a different angle. The Airbnb’s DQ score serves as a valuable tool for providing a concrete visualization of data quality. In essence, any initiative to enhance data quality should manifest a discernible impact on this score. On the other hand, Lyft presents one possible initiative to proactively enhance quality by testing and validating data against specific quality criteria. https://eng.lyft.com/from-big-data-to-better-data-ensuring-data-quality-with-verity-a996b49343f6?source=post_page-----415baad6c95b--------------------------------&embedable=true Fundamentally, it’s a different point in the data quality lifecycle. Introducing a mechanism to improve quality necessitates the ability to measure it initially. So, while ’s focus lies on and data quality, relying on the producer’s interest to enhance this quality and “look good,” Lyft takes a different approach. Lyft places emphasis on actively and data quality, providing both producers and consumers with the means to effectively improve and control the quality. Airbnb measuring observing testing validating Collectively, these approaches provide a comprehensive strategy to address and enhance throughout its . data quality lifecycle For this reason, I was particularly interested in taking a closer look at Lyft’s approach. Another factor that intrigued me is testing, more specifically, contract testing, which has been used for many years now in basic software engineering with the emergence of microservice architecture. Data contracts, however, are something more recent in the domain of data engineering and are seen as the pinnacle or one of the ultimate steps to put in place on the path to building high-quality data pipelines. This is why I wanted to examine Lyft’s approach in more detail and explore some potential parallels. As mentioned, the approaches taken by Airbnb and Lyft are complementary and aim to achieve the same goal: improving data quality. has developed the DQ score, which focuses on measuring and enhancing 4 distinct : Airbnb aspects of data quality DQ Score has guiding principles, including full coverage, automation, actionability, multi-dimensionality, and evolvability. It has dimensions like Accuracy, Reliability, Stewardship, and Usability. Lyft’s Verity is a platform designed to enhance data quality across 5 dimensions Defines data quality as the measure of how well data can be used as intended, covering aspects like . semantic correctness, consistency, completeness, uniqueness, well-formedness, and timeliness It’s easy to draw parallels between the 5 data quality aspects improved by Lyft’s Verity and the 4 data quality dimensions measured by the Airbnb’s DQ score. For example, aspects like Timeliness would certainly contribute to the DQ score’s Reliability, while Accuracy would be dependent on semantic correctness, completeness, and uniqueness of the data. The Usability score, on the other hand, is influenced by the consistency of the data among other factors. Lyft’s Verity focuses on defining related to . It follows a test-first and validation approach, whereas Airbnb’s unified DQ score emphasizes evaluating data quality through various dimensions. checks semantic correctness, consistency, completeness, uniqueness, well-formedness, and timeliness If we wanted to incorporate the DQ score into this last schema, it would be on the side of the Alert/Debug steps. Airbnb’s DQ score uses different signals to assess data quality across the . Accuracy, Reliability, Stewardship, and Usability aspects We also had a set of input signals that more directly measure quality (Midas certification, data validation, bugs, SLAs, automated DQ checks, etc.), whereas others were more like proxies for quality (e.g., valid ownership, good governance hygiene, the use of paved path tooling). As discussed earlier, there are likely overlaps between Airbnb’s DQ score and Verity. While Airbnb focuses on pushing data quality to the right, emphasizing measurement and scoring, Lyft’s Verity takes a proactive approach by shifting the check definition configurations, testing, and validation processes to the left, emphasizing proactive improvement of data quality. Now, my primary interest lies to the left, in the check definition configurations, testing, and validation aspects. How Lyft integrates data quality testing into its processes? Let’s first examine the execution paths. Currently, Lyft’s Verity is primarily focused on ensuring the quality of data stored in its Hive data warehouse. However, there are plans to expand its capabilities to support other data sources in the future. Note that while they refer to Hive as a data workhouse, they actually utilize it as a hybrid data storage solution, operating as a data warehouse for structured, processed, and cleansed data (silver layer) while also serving as a data lake for raw event data (bronze layer). Poor data quality in Hive caused tainted experimentation metrics, inaccurate machine learning features, and flawed executive dashboards. Verity’s checks can be integrated into an Airflow DAG to ensure that only high-quality raw data is processed and stored in Hive as derived data. Data producers and consumers can define their data quality checks and verify the data when it is produced or before it is consumed inside or . Airflow Flyte … The VerityAirflowOperator can be used in a blocking fashion to halt a DAG upon a check failure, preventing bad data from ever reaching production. This utilizes the “ ” pattern: we create data in a staged schema, verify the data with a blocking operator, then promote it to production if it passes quality checks. Stage-Check-Exchange Checks can also be performed manually or scheduled automatically to verify both raw and derived data. Verity Scheduled Checks are isolated from any data orchestration engine, so they still run even if Airflow or Flyte are completely down. This remedies a common problem of checks not alerting because the Airflow Task never ran. So, there are essentially 3 primary ways to trigger a check: as part of an Airflow DAG, manually, or scheduled through the Verity platform/UI. I don’t believe that current checks can be integrated into real-time streaming pipelines (such as Flink + Kafka) to validate for example data as it enters Hive (or even earlier). Implementing this type of real-time check would enable prompt detection of discrepancies, leading to reduced storage and processing costs and overall data quality enhancement. Well, to be thorough, Verity checks are managed through an API server, which could be used to trigger checks programmatically through some APIs. Verity API Server — This service handles all the external APIs regarding running checks as well as persisting and retrieving their results. The API Server does not execute any checks, but rather writes a message to our Check Queue, which utilizes (SQS). SimpleQueueService So, maybe, you could potentially trigger these jobs in a more real-time fashion, such as from a streaming job or even, as a long stretch, by integrating with Hive change data capture (CDC). However, when executed outside of Airflow, these jobs would not be able to block the data processing job; instead, they would generate asynchronous alerts pushed to the Check Queue. Some consumers would prefer to have data processing delayed when a check fails, while others would rather proceed and receive an alert. Now, let’s look at these data quality tests. Here’s an example that checks whether is never null. This is accomplished through a combination of query and condition components. rider_events.session_id core rider events session_id is not null: # check name
  metadata:
    id: 90bde4fa-148b-4f06-bd5f-f15b3d2ad759
    ownership_slack: #dispatch-service-dev
    tags: [rides, core-data, high-priority]
  query:
    type: dsl
    data_source_id: hive.core.rider_events
    filters:
      - session_id = null
  condition:
    type: fixed_threshold
    max: 0
  notifier_group:
    pagerduty_policy: dispatch-service
    email: dispatch-service@lyft.pagerduty.com Verity is primarily focused on defining and enforcing data quality checks rather than defining complete data schemas. Schema validation is not a novel concept. Several methods exist for defining event data schemas in event-based systems, such as JSON Schema, Protocol Buffers, Avro, or storage formats like Parquet. The optimal choice depends on your tech stack, usage, and specific requirements. While data schemas are valuable for defining the overall structure of data objects or table rows, they fall short in capturing more sophisticated validation checks specific to consumers, such as data distribution, business rules, SLAs, and thresholds. Data contracts go beyond schema validation, which focuses on identifying . I personally find that JSON Schema offers here a more suitable and readable option, effectively separating these structural and syntactical validation capabilities from serialization or storage concerns. syntactical errors However, to address and enhance data accuracy, having an effective means of defining data checks allows for defining the other facet of data contracts. semantic errors This is where Verity DSL comes into play. Beyond semantical validation, data contracts offer another crucial aspect that deserves attention. From a syntactical standpoint, validation checks remain consistent regardless of the consumer or producer involved. The set of validation rules is not tied to any specific consumer or producer and can be defined once and for all as a single schema. However, the Verity data contract DSL offers a finer granularity defining small independent rules, which is particularly well-suited for this context: the semantic meaning and usage of the data vary depending on the specific consumer. Additionally, not all consumers need to utilize all of the properties of an object. Their expectations differ. This doesn’t imply they are contradictory (which would certainly be an issue), but rather complementary and distinct ones. Therefore, allowing all consumers to establish unique rules that, when combined collaboratively, can provide a comprehensive understanding of the semantic significance of data quality is quite crucial. And it’s this aspect that particularly resonates with me. Bear with me, this may seem like a stretch, but from my perspective, it’s worth mentioning. :) collaborative Data exchange enables different teams (producers and consumers) to collaborate effectively. Establishing a shared understanding of these data exchanges is paramount, just like APIs in traditional software development. In microservice architectures, a known as consumer-driven contracts (CDC) has emerged, where consumers define the expected behavior of APIs provided by producers. Producers are responsible for verifying these contracts before releasing new versions. collaborative testing approach I think data contracts share a similar collaborative spirit. Even though data validation is performed on real data, rather than at release time, and does not block releases, it’s based on cooperation and encourages teamwork between data producers and consumers. I strongly believe that this collaborative approach is key to improving data quality and should be further integrated into the process. Well, I’m a big fan of drawing parallels… Notice actually that this collaborative aspect is something mentioned also as part of Lyft’s verity charter. The VerityUI provides a streamlined data discovery experience via the Verity Homepage. Our full-text search on the Check Definition Metadata lets users see all the checks currently being enforced and their Check Results. This has useful aggregations like owning team, table name, and tags. I’m not entirely clear on how data contract issues are shared between consumers and producers through the Verity platform UI, but I definitely recognize the significance of collaboration through the dashboards: The producer of a data product interface can confidently ensure that they’re not inadvertently causing downstream breakages that they hadn’t anticipated. The consumer of the interface can rest assured that their reliance on the interface is not and will not be compromised. While Verity is a remarkable tool for defining data quality checks, it’s unfortunately not open-source. Fortunately, there’s another open-source data quality framework called Soda Core that provides similar functionality. Soda Core is a free and open-source command-line tool and Python library that enables data engineers to test data quality. It utilizes user-defined input to generate SQL queries that run checks on datasets in a data source to find invalid, missing or unexpected data. When checks fail, they surface the data that you defined as “bad” in the check. https://medium.com/@seckindinc/soda-core-the-simplest-open-source-data-reliability-tool-f35ae5b576d9?source=post_page-----415baad6c95b--------------------------------&embedable=true During a scan of a dataset, Soda Core evaluates the predefined checks to identify invalid, missing, or unexpected data. Here’s the equivalent check using Soda.core syntax for the Verity DSL test that was previously defined. name: rider_events_session_id_check
source: hive
query: SELECT * FROM rider_events WHERE session_id IS NULL;
raise_alert: true
threshold: 10
action: slack
message: "There are more than 10 rows that are null for the 'session_id' property in the 'rider_events' table. Please investigate this issue." soda run --check checks/rider_events_session_id_check.yaml Soda Core is a powerful tool for ensuring the quality of your data. It can help you to identify and fix data problems early, before they can cause issues for your business. It’s worth noting that Soda Core can also facilitate data quality checks for streaming data by seamlessly integrating with Spark DataFrames. While Verity’s data quality checks for Hive are applied to static datasets, the checks for streaming data need to be more lightweight and efficient. Data would typically be processed in small batches of events, with very low latency, making them suitable for real-time checks and specific use cases like anomaly detection. Finally, let’s mention that there are other data validation tools available, such as DeeQu, Great Expectations, … As we wrap up, I hope you have a clearer understanding of the steps you can take to enhance your data quality journey. We’ve seen two distinct approaches to data quality improvement, each with its own strengths and methodologies. One focuses on increasing visibility and observability, motivating data producers to raise the quality bar. The other prioritizes elevating the quality standard through a testing and validation-first approach. Both are complementary. Verity is not merely a domain-specific language (DSL) for defining data checks; it’s a centralized platform that empowers data practitioners to collaborate effectively. This platform helps producers and consumers align on data quality expectations, including format, structure, and accuracy. Verity’s data contract management capabilities could (is?) further enhanced by integrating with a broader set of features, such as metadata management and discovery, to address more sophisticated data quality needs. Similar to Airbnb’s DQ score, Lyft’s Verity fosters a collaborative feedback loop between data producers and consumers. By incentivizing and empowering each team to take ownership of data quality, Verity cultivates a supportive environment where data quality continuously improves. , Found this article useful? Follow me on Linkedin , and ! Please 👏 this article to share it! Hackernoon Medium Also published . here

Advancing Data Quality: Exploring Data Contracts with Lyft

ডেটা গুণমান উন্নত করা: Lyft-এর সাথে ডেটা চুক্তিগুলি অন্বেষণ করা

Verbesserung der Datenqualität: Erkundung von Datenverträgen mit Lyft

Mejora de la calidad de los datos: exploración de los contratos de datos con Lyft

Améliorer la qualité des données : explorer les contrats de données avec Lyft

डेटा गुणवत्ता को आगे बढ़ाना: Lyft के साथ डेटा अनुबंध की खोज करना

データ品質の向上: Lyft とのデータ契約の検討

데이터 품질 향상: Lyft를 통한 데이터 계약 탐색

Avançando na qualidade dos dados: explorando contratos de dados com Lyft

Повышение качества данных: изучение контрактов на передачу данных с Lyft

Veri Kalitesini Geliştirme: Lyft ile Veri Sözleşmelerini Keşfetmek

Nâng cao chất lượng dữ liệu: Khám phá hợp đồng dữ liệu với Lyft

提高数据质量：与 Lyft 探索数据合同

It’s been a little over a year since the Journey’s End update for Terraria was released. With it, a new goal was given for players that already beat the final boss - to craft the Zenith, the most powerful weapon in the game. Though it’s a melee weapon, the Zenith outclasses pretty much every other item the player can get. It can phase through walls and reach as far as the screen allows, on top of dealing some of the highest damage that can be found in Terraria. It’s an incredible weapon, and the requirements to craft it are equally as ridiculous. Getting every item you need to craft the Zenith can be a tough journey from the moment you create your character, and there are plenty of variables to consider. This guide will set players on the best and quickest path towards obtaining the weapon, from character creation all the way up to the game’s end. Spoilers for end-game content ahead! DISCLAIMER: This guide is for the current PC version of Terraria, 1.4.2.3. A Guide to Obtaining Terraria’s Zenith Before you start playing If you’re making a brand-new character that you want to get the Zenith with, you can go about it in a few different ways. The most balanced option is to create a Classic (or Softcore) character. Mediumcore and Hardcore characters have too many risks associated with them, as the random generation of Terraria’s worlds makes it quite easy for players to suffer multiple deaths. This guide will assume you’re not playing in Journey Mode, as the difficulty options can negate any challenge that might get in the way of crafting the Zenith. When creating a new world, you’ll want to make a large one. The extra size will generate more spawn points for rare items, including vital components of the Zenith. You might also want to consider using the custom world seed “05162020”. This will force all types of ore to spawn, as well as generate both Corruption and Crimson in a world. It’s not a requirement to use that seed, but it definitely helps in providing more options than a normal world. As for difficulty, it depends on what your goal is. The best option, if your only concern is the Zenith, is Classic (or Normal) difficulty. Expert difficulty provides better accessories and loot, but the difficulty of even early-game bosses increases drastically - and none of its exclusive items are required to craft the Zenith. Master difficulty simply increases enemy health and damage taken, and should only be considered if you’re more interested in a challenge. Getting Started From the moment the player enters the world, there are four important weapons they can get their hands on. Players will need to make a Forge and an Anvil to craft one of those weapons, as well as many others down the line. Here are the Zenith components that can be found even before fighting your first boss: - All players, barring those in Journey Mode, start with this. You can’t use its counterpart, the Tin Shortsword, so be sure to keep it safe - especially if your world doesn’t have any more copper to spare. Copper Shortsword - This weapon is found in floating islands. Gravitation potions can be collected in chests underground, allowing players to easily reach these islands. It’s a useful weapon against bosses, as well, to the point where you might want to keep it in your inventory for the first few fights. Starfury - This weapon only generates in shrines located in the outer two-thirds of a world’s map. They can be tough to find, and they aren’t even guaranteed to spawn in some worlds. You might need to create an entire new world if you don’t get it on your first try. Enchanted Sword - A sword crafted with 12 Jungle Spores and 12 Stingers at an Anvil. It’s not a very special sword on its own, but it’s one of the components of the Night’s Edge - a more powerful weapon that will bring you one step closer to the Zenith. Blade of Grass Reaching Hardmode Image via Fanmade YouTube Thumbnail Players will need to defeat nearly every boss before reaching hardmode, with the exception of King Slime. You can also choose whether or not to defeat the Eye of Cthulhu or the Corruption/Crimson bosses, as they drop similar resources. - Crafted with 10 Demonite or 10 Crimtane Bars at a Forge. You don’t need both, as either one acts as a necessary component in crafting the Night’s Edge. Light’s Bane or Blood Butcherer - A sword dropped by the Queen Bee. It only has a 33% chance of dropping from the boss, so you might need to farm for it. If you’re desperate, you can use the custom seed “not the bees” to make a new world filled with Larvae, allowing you to spawn the boss numerous times over. Bee Keeper - A sword found in the dungeon. You’ll need to defeat Skeletron and search for Golden Keys, as it can only be obtained from Locked Gold Chests. Muramasa - Crafted using 20 Hellstone Bars at an anvil. You’ll need to make the bars with a total of 60 Hellstone and 20 Obsidian at a Hellforge. Hellstone can only be obtained with a pickaxe at 65% power or higher, and Obsidian is made through forcing water and lava to collide. Fiery Greatsword - Crafted at a Demon or Crimson Altar using the Blade of Grass, Muramasa, Fiery Greatsword, and either the Light’s Bane or the Blood Butcherer. The strongest sword before entering Hardmode, and one step closer to the strongest sword in the game. Night’s Edge Crafting the Terra Blade Image via Steam Community Once players defeat the Wall of Flesh and enter hardmode, they’ll reach a far more difficult point in their journey. A Mythril or Orichalcum Anvil should be crafted as soon as possible, alongside an Adamantite or Titanium Forge. The hardmode Anvils are where you’ll be making the rest of the craftable swords. Afterwards, players will need to take down the three mechanical bosses and Plantera, finally getting the tools they need to craft a vital component of the Zenith. - Crafted at a hardmode Anvil using 12 Hallowed Bars. Each Mechanical Boss drops a minimum of 15 - more than enough to make the Excalibur after beating just one. Excalibur - Crafted at a hardmode Anvil. It requires the original Night’s Edge alongside 20 of each mechanical boss’s soul. Again, not much farming is required to make this weapon, as the bosses drop more than enough souls for players wanting to craft it. True Night’s Edge - Crafted at a hardmode Anvil. It requires the original Excalibur alongside 24 Chlorophyte Bars. These bars must be made from a hardmode Forge using a total of 120 Chlorophyte Ore, which can be obtained with a Drax or a Pickaxe Axe. These tools are obtainable after defeating all three mechanical bosses, using one of each type of their soul. True Excalibur - Dropped by Plantera. It only has an 11% chance of being obtained, so you might need to fight this boss more than once. It’s not a component of the Terra Blade, but I’m mentioning it here since it’s possible to obtain the Seedler first. Seedler - Crafted at a hardmode Anvil. It requires the True Night’s Edge, the True Excalibur, and a Broken Hero Sword. The final component is dropped by Mothron, an enemy that only appears during Solar Eclipses after Plantera is defeated. Terra Blade The Final Components Image via YouTube The Terra Blade is more than capable of assisting players all the way up to the final boss of Terraria. Only four more weapons are needed, but getting them won’t be any easier. - Dropped by Pumpking, a miniboss that appears starting on wave 7 of the Pumpkin Moon event. The item used to start the event must be crafted at a hardmode Anvil using 30 Pumpkins (which can be planted after buying seeds from the Dryad), 5 Ectoplasm (obtained from the dungeon after beating Plantera), and 10 Hallowed Bars. Killing one Pumpking won’t guarantee you get the weapon, but it’s more likely to drop during later waves; fight efficiently and it’ll be yours before long. The Horseman’s Blade - Dropped by the Martian Saucer, a miniboss that appears during the Martian Madness event. The event can be initiated by looking for Martian Probes around the map and letting them escape after they see you. This weapon isn’t a guaranteed drop, either, but its chances won’t increase as the event goes on. You might need to initiate this event multiple times before you get your hands on the Influx Waver. Influx Waver - A weapon dropped by the Moon Lord, the final boss of Terraria. Even with such a monumental achievement needing to be fulfilled, it only has an 11% chance of being dropped by the boss. Not that it matters, as you’ll need to fight the Moon Lord at least once more anyway. Star Wrath - Another weapon dropped by the Moon Lord. You can’t obtain both it and the Star Wrath at the same time, so you’ll need to defeat the Moon Lord a minimum of two times. Meowmere End of the Guide - Crafting Terraria’s Zenith After having obtained every item on this list, you’re finally ready to craft the Zenith. With everything prepared, you’ll need to bring these weapons to a hardmode Anvil: Copper Shortsword Starfury Enchanted Sword Bee Keeper Terra Blade Seedler The Horseman’s Blade Influx Waver Star Wrath Meowmere With that, the Zenith should appear as a craftable item, just waiting for you to click on it. Once you’ve done so, pat yourself on the back and congratulate yourself - you’ve obtained the strongest weapon in Terraria history! Since you’ve already defeated the final boss at least twice over, there admittedly isn’t much you can do with the Zenith. But you can always make new words on harder difficulties and use it to plow through everything you come across. Sometimes, a bit of power fantasy is the perfect end to such a lengthy journey. Information and additional images sourced from the . Official Terraria Wiki More in gaming: 1. An Essential Dark Souls Mods Guide: The Best Mods from Dark Souls 3 to Dark Souls Remastered | Hacker Noon 2. PC Gaming Accessories and Peripherals: A Starter's Guide | Hacker Noon 3. 10 Best Cheap and Free VR Games on Steam | Hacker Noon

Stories, News & Mentions about SOFASCORE

Sofascore’s Stories on HackerNoon

Sofascore's News & Mentions