Get the most recent info and news about WeTransfer on HackerNoon, where 10k+ technologists publish stories for 4M+ monthly readers.

WeTransfer is a collection of secure file transferring and creative collaboration tools designed to keep your ideas moving seamlessly.

WeTransfer

wetransfer

- Integrated payments to roll out globally in 190 countries, following a successful test in North America and Canada, , - The new release is designed to tackle last mile payments amid 87% content creators reporting late or missed invoices, , - <strong>WeTransfer</strong> to waive additional platform fees for ...

WeTransfer unveils payments to help creatives earn money | WebWire

This paper is under CC 4.0 license. available on arxiv Authors: (1) Zhe Liu, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China; (2) Chunyang Chen, Monash University, Melbourne, Australia; (3) Junjie Wang, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China & Corresponding author; (4) Mengzhuo Chen, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China; (5) Boyu Wu, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China; (6) Zhilin Tian, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China; (7) Yuekai Huang, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China; (8) Jun Hu, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China; (9) Qing Wang, State Key Laboratory of Intelligent Game, Beijing, China Institute of Software Chinese Academy of Sciences, Beijing, China; University of Chinese Academy of Sciences, Beijing, China & Corresponding author. Table of Links Abstract and Introduction Motivational Study and Background Approach Experiment Design Results and Analysis Discussion and Threats to Validity Related Work Conclusion and References 3 APPROACH This paper aims at automatically generating a batch of unusual text inputs which can possibly make the mobile apps crash. The common practice might directly produce the target inputs with LLM as existing studies in valid input generation [44] and fuzzing deep learning libraries [20, 21]. Yet, this would be quite inefficient for our task, because each interaction with the LLM requires a few seconds waiting for the response and consumes lots of energy. Instead, this paper proposes to produce the test generators (a code snippet) with LLM, each of which can generate a batch of unusual text inputs under the same mutation rule (e.g., insert special characters into a string), as demonstrated in Figure 4 ⑤. To achieve this, we propose InputBlaster which leverages LLM to produce the test generators together with the mutation rules which serve as the reasoning chains for boosting the performance, and each test generator then automatically generates a batch of unusual text inputs, as shown in Figure 3. In detail, given a GUI page with text input widgets and its corresponding view hierarchy file, we first leverage LLM to generate the valid text input which can pass the GUI page (Sec 3.1). We then leverage LLM to produce the test generator which can generate a batch of unusual text inputs, and simultaneously we also ask the LLM to output the mutation rule which serves as the reasoning chain for guiding the LLM in making the effective mutations from valid inputs (Sec 3.2). To further boost the performance, we utilize the in-context learning schema to provide useful examples when querying the LLM, from online issue reports and historical running records (Sec 3.3). 3.1 Prompt Generation for Valid Input InputBlaster first leverages LLM to generate the valid input which will serve as the target towards which the following mutation can be conducted. The context information relates to the input widgets and its belonged GUI page can provide important clues about what the valid input should be, therefore we input this information into LLM (in Section 3.1.1). In addition, we also include the dynamic feedback information when interacting with the input widgets (in Section 3.1.2), and the constraint categories we summarized in the previous section (in Section 3.1.3) to improve the performance. Furthermore, besides the valid text input, we also ask LLM to output its inferred constraints for generating the valid input which will facilitate the approach to generating the mutation rules in the next section. We summarize all the extracted information with examples in Table 1. The context information is extracted from the view hierarchy file, which is easily obtained by automated GUI testing tools [26, 48, 49, 61]. As shown in Table 1, we extract the text-related field of the input widget which indicates how the valid input should be. In detail, we extract the “hint text”, “resource id”, and ‘text’ fields of the input widget, and utilize the first non-empty one among the above three fields. 3.1.1 Context Extraction. We also extract the activity name of the GUI page and the mobile app name, and this global context further helps refine the understanding of the input widget. In addition, we extract the local context of the input widget (i.e., from nearby widgets) to provide thorough viewpoints and help clarify the meaning of the widget. The candidate information source includes the parent node widgets, the leaf node widget, widgets in the same horizontal axis, and fragment of the current GUI page. For each information source, we extract the “text” field (if it is empty, use the “resource-id” field), and concatenate them into the natural-language description with the separator (‘;’). When one inputs an incorrect text into the app, there are some feedbacks (i.e., dynamic hints) related to the inputs, e.g., the app may alter the users that the password should contain letters and digits. The dynamic hint can further help LLM understand what the valid input should look like. 3.1.2 Dynamic Hint Extraction. We extract the dynamic hints via differential analysis which compares the differences of the GUI page before and after inputting the text, and extracts the text field of the newly emerged widgets (e.g., a popup window) in the later GUI page, with examples shown in Figure 2. We also record the text input which makes the dynamic hint happens, which can help the LLM to understand the reason behind it. Our pilot study in Section 2.1.2 summarizes the categories of constraints within and among the widgets. The information can provide direct guidance for the LLM in generating the valid inputs, for example, the constraint explicitly requires the input should be pure text (without special characters). We provide this list of all candidate constraints described in natural language as in Section 2.1.2 to the LLM. 3.1.3 Candidate Constraints Preparation. With the extracted information, we use three kinds of information to generate prompts for inputting into the LLM, as shown in Table 1. Generally speaking, it first provides the context information and the dynamic hints (if any) of the input widgets, followed by the candidate constraints, and then queries the LLM for the valid input. Due to the robustness of LLM, the generated prompt sentence does not need to fully follow the grammar. 3.1.4 Prompt Generation. After inputting the prompt, the LLM will return its recommended valid text input and its inferred constraints, as demonstrated in Figure 4 ②. We then input it into the widget, and check whether it can make the app transfer to the new GUI page (i.e., valid input). If the app fails to transfer, we iterate the process until the valid input is generated. 3.2 Prompt Generation for Test Generator with Mutation Rule Based on the valid input in the previous section, InputBlaster then leverages LLM to produce the test generator together with the mutation rule. As demonstrated in Figure 4 ⑤, the test generator is a code snippet that can generate a batch of unusual inputs, while the mutation rule is the natural language described operation for mutating the valid inputs which automatically output by LLM based on our prompt and serves as the reasoning chain for producing the test generator. Note that the mutation rule here is output by LLM. Each time when a test generator is produced, we can obtain a batch of automatically generated unusual text inputs, and will input them into the text widgets to check whether they have successfully made the mobile app crash. This test execution feedback (in Section 3.2.2) will be incorporated in the prompt for querying the LLM which can enable it more familiar with how the mutation works and potentially produce more diversified outcomes. We also include the inferred constraints in the previous section in the prompt (in Section 3.2.1), since the natural language described explanation would facilitate the LLM in producing effective mutation rules, for example, the inferred constraint is that the input should be in pure text (without special characters) and the LLM would try to insert certain characters to violate the constraint. We have obtained the inferred constraints and valid input from the output of the LLM in the previous section, here we extract this information from the output message and will input it into the LLM in this section. We design a flexible keyword matching method to automatically extract the description between the terms like ‘constraints’ and ‘the input’ and treat it as the inferred constraints, and extract the description after the terms like ‘input is’ and treat it as the valid input, as demonstrated in Figure 4 ②. 3.2.1 Inferred Constraints and Valid Input Extraction. After generating the unusual text inputs, we input them into the mobile app and check whether they can successfully trigger the app crash. This test execution information will be inputted into the LLM to generate more effective and diversified text inputs. We use the real buggy text inputs and the other unusual inputs (which don’t trigger bugs) to prompt LLM in the follow-up generation. The former can remind the LLM to avoid generating duplicate ones, while the latter aims at telling the LLM to consider other mutation rules. 3.2.2 Test Execution Feedback Extraction. Besides, we also associate the mutation rules with the text input to enable the LLM to better capture its semantic meaning. As shown in Figure 4 ⑤, we extract the content between the keywords “Mutation rule” and “Test generator” as mutation rules. With the extracted information, we design linguistic patterns of the prompt for generating the test generator and mutation rules. As shown in Figure 4 ④, the prompt includes four kinds of information, namely inferred constraints, valid input, text execution feedback, and question. The first three kinds of information are mainly based on the extracted information as described above, and we also add some background illustrations to let the LLM better understand the task, like the inferred constraint in Figure 4 ④. For the question, we first ask the LLM to generate the mutation rule for the valid input, then let it produce a test generator following the mutation rule. Due to the robustness of LLM, the generated prompt sentence does not need to follow the grammar completely. 3.2.3 Prompt Generation. 3.3 Enriching Prompt with Examples It is usually difficult for LLM to perform well on domain-specific tasks as ours, and a common practice would be employing the in-context learning schema to boost the performance. It provides the LLM with examples to demonstrate what the instruction is, which enables the LLM better understand the task. Following the schema, along with the prompt for the test generator as described in Section 3.2, we additionally provide the LLM with examples of the unusual inputs. To achieve this, we first build a basic example dataset of buggy inputs (which truly trigger the crash) from the issue reports of open-source mobile apps, and continuously enlarge it with the running records during the testing process (in Section 3.3.1). Based on the example dataset, we design a retrieval-based example selection method (in Section 3.3.2) to choose the most suitable examples in terms of an input widget, which further enables the LLM to learn with pertinence. We collect the buggy text inputs from GitHub and continuously build an example dataset that serves as the basis for in-context learning. For each data instance, as demonstrated in 4 ③, it records the buggy text inputs and the mutation rules which facilitate the LLM understanding of how the buggy inputs come from. It also includes the context information of the input widgets which provides the background information of the buggy inputs, and enables us to select the most suitable examples when querying the LLM. 3.3.1 Example Dataset Construction. First, we automatically crawl the issue reports and pull  requests from the Android mobile apps in GitHub (updated before September 2022). Then we use keyword matching to filter these related to the text inputs (e.g., EditText) and have triggered crashes. Following that, we then employ manual checking to further determine whether there is a crash triggered by the buggy text inputs by running the app. In this way, we obtain 50 unusual inputs and store them in the example dataset (There is no overlap with the evaluation datasets.). We then extract the context information of the input widget with the method in Section 3.1.1, and store it together with the unusual input. Note that, since these buggy inputs don’t associate with the mutation rules, we set them as null. Mining buggy text inputs from GitHub. We enrich the example dataset with the newly emerged unusual text inputs which truly trigger bugs during InputBlaster runs on Enlarging the dataset with buggy text inputs during testing. various apps. Specifically, for each generated unusual text input, after running it in the mobile apps, we put the ones which trigger crashes into the example dataset. We also add their associated mutation rules generated by the LLM, as well as the context information extracted in Section 3.1.1. Examples can provide intuitive guidance to the LLM in accomplishing a task, yet excessive examples might mislead the LLM and cause the performance to decline. Therefore, we design a retrieval based example selection method to choose the most suitable examples (i.e., most similar to the input widgets) for LLM. 3.3.2 Retrieval-based Example Selection and In-context Learning. In detail, the similarity comparison is based on the context information of the input widgets. We use Word2Vec (Lightweight word embedding method) [50] to encode the context information of each input widget into a 300-dimensional sentence embedding, and calculate the cosine similarity between the input widget and each data instance in the example dataset. We choose the top-K data instance with the highest similarity score, and set K as 5 empirically. The selected data instances (i.e., examples) will be provided to the LLM in the format of context information, mutation rule, and buggy text input, as demonstrated in Figure 4 ③. 3.4 Implementation We implement InputBlaster based on the ChatGPT which is released on the OpenAI website[3]. It obtains the view hierarchy file of the current GUI page through UIAutomator [65] to extract context information of the input widgets. InputBlaster can be integrated by replacing the text input generation module of the automated GUI testing tool, which automatically extracts the context information and generates the unusual inputs. [3] https://beta.openai.com/docs/models/chatgpt

Leveraging LLMs for Generation of Unusual Text Inputs in Mobile App Tests: Approach

This is a continuation of my article on CBDC (Central Bank Digital Currency) from the “Now You Understand” series. , I looked at what a CBDC is, and how this form of digital currency can be used, how it differs from stablecoins, and why private rather than public blockchains are used to implement CBDC solutions. In the first part You can read it here ⬇️ https://hackernoon.com/now-you-understand-central-bank-digital-currency-cbdc-explanation-and-usage-part-i?embedable=true In this part, I will look at what solutions are being used in different states to implement CBDCs, take a closer look at the Brazilian DREX case study, and follow the dynamics of CBDC implementation around the world. Enjoy reading! What solutions are countries using to implement CBDC? To implement CBDC, central banks will need a blockchain infrastructure. In this section, we’ll discuss the technical characteristics of the most common blockchain platforms for implementing digital currencies. During the research for this article, I conducted a thorough analysis of different solutions and platforms. My findings show that Based on the data and sources studied, it is evident that a few select blockchain platforms will be used prominently in various countries for CBDC implementation. Hyperledger Blockchain is emerging as a dominant tool in this domain. In addition, notable platforms such as Quorum and R3 Corda are actively used in significant projects (e.g., Dunbar, Jura). The selection of these platforms is driven by their popularity and track record, particularly in facilitating CBDC implementation. Hyperledger Besu Besu is an EVM-compatible blockchain platform with additional functionality to provide privacy capabilities. It supports private smart contracts and transactions. In the corporate sector, this is a must-have for technology adoption at all stages. Privacy became possible here due to a separate set of nodes that is responsible for encrypting private transactions. The Besu client does not include built-in private key management. External tools, such as Ethereum-compatible wallets, are used to manage private keys and sign transactions. This provides a greater level of security and flexibility. Besu is a permissioned network. It allows you to list approved accounts and deny all transactions from accounts that are not on the list. It allows you to determine which nodes can connect and participate in the network and which cannot. This is also achieved by adding nodes to the list of approved nodes, if a node is not on this list it is denied access to the network. This increases overall security and access control as well. Since only selected members can participate in the network, it significantly increases throughput. Hyperledger Fabric Fabric is a private blockchain platform designed for enterprise use, with a focus on privacy. It was initially developed by IBM and was transferred to the Linux Foundation in 2015. Unlike Besu, Fabric is not an EVM-compliant platform and has a different architecture, smart contracts are called chaincodes which are developed using , JS/TS, and . Go Java Fabric architecture includes a special type of node that is responsible for transaction processing, computation, and state management, they are called endorsers/committers. Another type of node called Orderers is responsible for reaching consensus, sequencing transactions, and placing them into blocks. For a higher level of privacy, another element called channels is implemented. Channels are represented as subnets in which only participating nodes have access to chain codes and transactions, while participants outside the channel are unaware of their existence, providing a high level of privacy and confidentiality. This functionality can be especially useful when there is a requirement to separate several directions and isolate them from each other. In Fabric, private transactions are also possible through direct P2P communications. In this scenario, only the hashes of the input data of the transaction are shared with the Orderers nodes and written to the ledger along with the transaction. Fabric supports pluggable consensus mechanisms, which means there is flexibility to choose the most suitable option for specific challenges and requirements. As Fabris is a private solution, this also means that a node in this network can only be started with the permission of authorized entities, which restricts the network participants. Hyperledger Iroha Launched in 2019, Iroha is a private blockchain platform that is also focused on enterprise use. The difference is that it has a simpler design and is easier to integrate thanks to its modular architecture. It also supports smart contracts. This platform is primarily performance-oriented with its own fault-tolerant consensus algorithm under the hood. It provides high throughput and low delay in transaction processing. A node can only be launched on this network with the permission of authorized entities. On this platform, Cambodia launched Bakong, a project controlled by the Central Bank of Cambodia, which is designed for mobile payments and banking. There was a problem with the coverage of banking services, and this project solved that problem by allowing all citizens to open an account and make cashless and secure payments. And for banks, it opened up the possibility of interbank transfers at a lower cost. This project is not entirely a CBDC, although it is administered by the Central Bank, but rather a tokenized deposit system. Quorum Quorum is an enterprise blockchain platform that is based on Ethereum but extended with functionality customized to the specific requirements of corporate clients. The platform was founded by J. P. Morgan Chase in 2016. In 2020, Consensys bought Quorum and now supports and develops the platform. The special feature of this platform is that it has a built-in privacy functionality, which opens up opportunities for corporate use. For example, there is the option for private transactions. This is very important compared to an open network because when we transfer money, we don't want anyone to know about it. The control of this platform is based on consensus mechanisms which assume that only selected participants are allowed to participate and maintain control of the network. For example, governance may be centralized at the Central Bank. Such a mechanism not only consolidates power in the system, but also provides a number of benefits, such as increased throughput and transaction speed. This is achieved by the fact that the number of nodes to reach a consensus between is minimal and limited. There is no need to wait for a large number of participants to agree. Unlike Ethereum, Quorum has zero gas costs, which means you don't need to pay for gas for transactions. As Quorum is based on Ethereum, it supports smart contracts in Solidity. Smart contracts open up the possibility of creating their applications, e.g. by commercial banks with permission from central banks. Smart contracts in Quorum can be as private as transactions. Similarly to a regular contract, for confidentiality reasons, it is necessary that they are not available to anyone. When we buy or sell a property, we don't want anyone to know the terms of the transaction and its participants. Smart contracts are deployed on the blockchain and are always available for interaction, the code is executed when called, so there is no need for a third party. For example, when we make a transaction, we have to wait for a third party, such as a bank, to execute it. In the case of smart contracts, we have no such need because everything is done by the executable code. Such interaction is always available 24/7, unlike standard organizations. They are also an excellent way to tokenize assets or access rights. Corda Corda platform is based on distributed ledger technology (DLT), but it is not a blockchain. That's why it's different from all the others. This platform is fully focused on privacy and by default all transactions are private. It does not have a global shared ledger and only supports transactions in which only counterparties are involved. Transactions are only related to bilateral or multilateral agreements between counterparties. Here each node maintains its own register of transactions, where they are linked to each other and complete in real time since there is no blockchain. But in this case the issue of double spending and others arise. Here this is solved by installing a notary which is a third party and controls the validity of transactions. Notary is a separate set of nodes and the level of decentralization is directly related to Notary. The model is based on strict confidentiality and each node must prove that it has been validly connected to the network using a certificate from authorized members. The signature capability here exists only on the nodes. Each application here exists only in the nodes of the network as well as the ability to sign transactions. This is significantly different from the standard Ethereum model where signature control is maintained by the client wallets. In fact, they simply run the process and control its execution. Here these applications are called CorDapp. : Drex (Digital Brazilian Real) Example of a CBDC implementation Brazil has launched its own CBDC called Drex (Digital Brazilian Real) in pilot mode on the Hyperledger Besu platform. As we know, it is an EVM-compliant blockchain, which means that it supports smart contracts in Solidity. The control architecture of the network is structured in such a way that it is centralized at the Central Bank and therefore managed completely privately. A node can only launch on this network with the permission of the Central Bank. End users can only have custodial wallets managed by an organization that has been authorized by the Central Bank, such as a commercial bank. There are retail and wholesale forms of CBDC. The wholesale form is intended only for high-volume transactions, such as between banks, cooperatives and possibly with the participation of large corporations. The retail form is designed for payments and transfers between individuals and businesses of any size and can be used for everyday financial transactions in any value range. In this implementation, CBDCs are smart contracts on Solidity ERC-20 standards, there are two main ones: RealDigital and RealTokenizado. The main token is RealDigital, which is controlled by the central bank. Other participants in the system, such as commercial banks and other financial institutions control their own token, RealTokenizado, which actually extends the RealDigital contract and its functionality. RealTokenizado is used to manage deposits and accounts. RealDigital itself stands as a reserve for all tokens of other participants. As we have different ERC-20 tokens for each participant they cannot be transferred directly, for this purpose swap contracts are used additionally. Therefore, when different tokens (RealTokenizado) are transferred between participants, it looks this way: RealTokenizado tokens (of one participant) are burned from the sender, RealDigital tokens (represent a reserve) are transferred from the sender to the receiver and RealTokenizado tokens (of another participant) are issued to the receiver. In this architecture there are also roles responsible for issuing, burning, moving and freezing funds. It is also important to say that participants, such as commercial banks, operate through a special account established by the Central Bank and cannot independently issue or burn RealTokenizado tokens. Stages of CBDC implementation worldwide In the first half of 2021, only 74 countries were interested in CBDC. Of these, only 3 decided not to develop this direction, 28 countries were in the research stage, 14 countries were in the development stage, 18 countries launched their own CBDCs in pilot mode and 1 country completely launched. By mid-2023, the picture has changed significantly, from the key parameters - now 130 countries have expressed interest, of which 46 are in the research stage and 32 are in the development stage. Pilot mode has been launched in 21 countries and 11 countries have fully launched. It is important to note that these 130 countries that are expressing interest in CBDC represent 98% of the world's GDP. From this we can conclude that this direction is of interest to the majority of countries in the world and has huge potential, and the active growth in the rate of research and development indicate that it is likely to be realised on a grand scale. The world situation at the moment is as follows: My opinion on CBDCs Even though many crypto enthusiasts believe that current CBDC implementations by central banks are not in line with the basic principles of the crypto community, I suppose that CBDC implementations should not be measured by public blockchains. CBDC implementations most often have fully centralized control, which crypto enthusiasts are against, but it should be understood that CBDCs cannot and should not be implemented otherwise. This is due to many considerations, including privacy and legality of transactions.  Yes, such a centralized implementation loses some of the advantages of public blockchains, but at the same time, it solves more important country-specific issues and reduces risks. Conclusion There is a significant global interest in CBDC implementation, which indicates a high promise of changing the traditional system towards CBDC and tokenization of assets. For CBDC implementation, private solutions are used that provide privacy control and centralized control over the Central Bank. They also support a high level of programmability, which makes it possible to create your own rules for CBDC. Unlike public networks, there are no transaction fees. Because transactions occur according to programmed rules - there is no need for a third party to verify them, and therefore these solutions are available 24/7. Control over the private network is limited to selected members and there is no need to wait for the majority to agree as in the case of public networks. CBDCs enable the tokenization of assets and property, optimizing the costs of the current registry infrastructure and increasing security, speed, and cost of transactions. Smart contracts in CBDCs open up opportunities to automate many processes and increase their security, including cross-border payments. Digitizing money makes it more transparent, efficient, controllable and accessible, removing vulnerabilities and inefficiencies in the current infrastructure.

Now You Understand: Central Bank Digital Currency (CBDC)—Explanation and Usage, Part 2

In the modern world, all of our actions come under the scrutiny of authorities and corporations. The former watch where we earn money, the latter whether we spend it “correctly”. The state tried to take control of even a person’s thoughts. The emergence of the Internet marked a chance for the free exchange of ideas and information. Cryptoanarchists began to actively use this chance. Cryptoanarchy is a political and philosophical ideology that calls for the use of cryptographic technologies such as encryption and digital currencies to achieve greater personal freedom, privacy, and autonomy from centralized authorities, including governments and corporations. Cryptoanarchists subscribe to the ideas that all communication should be private and anonymous if the individual wants it to be, especially in times where one can go to jail for saying the “wrong” word. Anonymity is the catalyst for people to lose their fear of sharing their thoughts, creating a field for free communication. The next important component is the autonomy and decentralization that the Internet has given people. With proper utilization of the network, a user can stay out of the sight of authorities and corporations. All the above mentioned benefits can be achieved with the help of cryptography. Cryptography Cryptography has its roots in wartime, when the secure transmission of information was vital. Primitive methods of encrypting forwarded messages meant that within a short period of time the key to decryption would be found. This meant that the threat of decryption was permanently present. There were many instances in the history of World War II where the key was solved before the message reached the recipient. This encouraged the military and governments to create ever more sophisticated forms of encryption. Many movies have been made on this subject. In the post-war period, these technologies were improved by governments. The USA took a special part in this process. For example, the well-known Tor browser was developed by the U.S. intelligence services for military and political purposes, but we will talk more about this in another article. So, today cryptography has reached the point where even the most powerful computer in the world would take about 150–200 years to find the key. This makes the blockchain system, which is based on public key cryptography, as secure as possible today. The essence of this system is that it generates 2 different keys for each user of the network. One key is public and the other is private. The combination of the public and private key unlocks the data in the registry. This combination allows operations to be secure and anonymous today. Please note that it is for today, as technology is moving forward continuously, and hackers are not slumbering either, improving and perfecting possible attacks. What is safe this second may not be safe in an hour. It is important to actively monitor information to stay up-to-date on the latest information security developments. Cypherpunks and cryptoanarchy In the second half of the 1980s, when there was a threat of governments controlling the free Internet, a movement of cypherpunks emerged that advocated the privacy of all activities on the Internet. It was they who went on to improve cryptography technology. Over time, their ideas began to affect not only confidential communication on the network, but also problems of a governmental nature. By the end of the last century, it became obvious that the mistakes of the government are very expensive for ordinary people. The ideology of the cypherpunks was based on freedom from government control and oppression. Realization that taxpayers’ money was being spent on wars and political intrigues, prompted these people to carry out activities against the state. One prominent example is the emergence of WikiLeaks, which publicized abuses of power. Today, the cypherpunk movements have expanded beyond a small Internet community and have gained followers all over the world and among different social classes. Now virtual communities based on similar ideology can be found in any language, some even have a physical location. Virtual communities and projects One of the prime examples of a virtual community is Cyberpunks. It was they who created the first platform where participants could anonymously share their ideas, discuss theories and collaborate on projects. It was there that the idea of creating digital money, which formed the basis of the Bitcoin philosophy, was first conceived. Concepts such as public key cryptography, digital signatures and hash functions, which are fundamental to Bitcoin’s operation, were topics of intense discussion among community members. In fact, Cyberpunks was not just a forum, but an incubator of revolutionary ideas and technologies that have shaped our future. The identity of Satoshi Nakomoto, the creator or creators of Bitcoin, is unknown to this day, but it can be assumed that he/she/they either directly participated in these discussions or actively observed them. One way or another all of these ideas formed the basis of Bitcoin. Anonymous payments and cryptoanarchism As we have already found out above, cryptoanarchism is impossible without making anonymous payments. The first step in getting rid of government control is the freedom of money. In today’s world, any transaction that a bank does not like can lead to account blocking and sometimes even litigation. The world lives under the illusion that people own their money and property, but in reality this is not the case. I dare to assume that every person has faced the fact that at any moment there can be a call from the bank with a demand to report on the origin of funds or the purpose of payment. In case of unsatisfactory answer, access to funds may be blocked. In today’s banking system, confidentiality is simply impossible. Banks see where we eat, where we buy clothes, at which gas stations we fill up, to whom we transfer our money. If necessary, all this information (by which geolocation can be established in a matter of minutes), will be transferred to the state authorities. Is it possible to avoid total state control? The answer is positive. We will talk about the possibility of anonymous payments in the next article.

The Cryptoanarchist's Cookbook

Oh the world of blockchain technology, once such a calm and peaceful realm, where we lay under the trees of Bitcoin-topia, the only thoughts running through our minds was the blazing hopes of liberation from the clutches of calamitous monetary policy and dubious governments, using Satoshi’s golden gift to the world. Times have changed, and now we are spoiled for choice, as there are a plethora of different ecosystems we may choose to call home, all with their draws and benefits. The initial lack of interoperability between ecosystems led to many questions being asked; do we need all these chains? how do we transfer between them? How can we increase interoperability? What's the point? what does the future of the blockchain world look like? , and it’s time to give the people what they want and clear it all up. Every answer leads us to encounter the same 3 buzzwords The definitive differences between Omnichain, Multichain and Cross-Chain Let's nail down one key detail that brings all of this together: Interoperability What is Interoperability When we talk about interoperability, we generally refer to the way networks communicate data to each other. This is a pivotal factor in a decentralised ecosystem, as without interoperablility, there is no way for users to send data to and from different networks. Previously, Ethereum network held upwards of 95% of all the TVL, and to get across to other networks was quite arduous, as well as time and resource-consuming — generally just a pain. The lack of interoperability was a serious issue and is something that needed to be solved. Before delving deeper, we need to understand why there are so many different networks, and it all stems from the Blockchain Trilemma. What is the Blockchain Trilemma? As is in the real world, we can’t have it all. For Blockchains, the sacrificial scale is called the Blockchain Trilemma. There are 3 main points to this Trilemma (naturally) and they are: — The ability of a blockchain network to manage high transaction volumes efficiently. Scalability Decentralization is essentially the dispersion of decision-making power away from a central authority, to many individuals, in this case, it would be to nodes. Decentralisation — This refers to the integration of a complete risk management system, where trust in transactions is ensured through the foundations of a blockchain security framework (consensus, cryptography, and decentralization). Security — , as to achieve efficiency in 2 points, one must be sacrificed. This is where we saw the developments in Layer 2 networks (Optimism, Arbitrum, Polygon etc) begin, as they solved the issues that Ethereum (A Layer 1) had with scalability. Layer 1 Blockchains suffer from this curse (the main blockchain). By being built on top of a Layer 1 network, the Layer 2 networks benefit from the decentralisation and security the Layer 1 has and then use their technology to fix the issues with scalability, thus solving the Trilemma (albeit at the cost of a slightly more complicated user experience). Layer 2 Networks sit atop of Layer 1 Networks The way they do this can vary depending on the Layer 2 — whether they be Optimistic Rollups (Optimism, Arbitrum), zkRollups (zkSynce, Starknet) or sidechains (Polygon). At the end of the day, they all reduce transaction costs significantly and have much higher Transactions per Second than their parent chain. This can be a lot to take in, and it may seem that this is a slight deviation but it’s important, as many new chains are being created in an attempt to solve this Trilemma, but ultimately, they were all inherently different and previously unconnected. This brings us to DeFi Summer (AKA Summer of 2020), and the rise of CrossChain Bridges. What is a Cross-Chain Bridge? Thankfully, the definition of a cross-chain bridge is quite intuitive — it bridges data between unrelated networks. The beauty of bridges is that they take manual labour out of the equation, and save a lot of time. Let’s say we have 1ETH — an ERC20 token, and we want to transfer it to the Solana network. Previously, you would have had to go through a centralised exchange (CEX), sell your for Solana, withdraw it to the Solana network, and then you would be left with 1ETH~ worth of Solana, which you can do what you want with. This process can be time-consuming (authenticate this and that), resource intensive, and if you are trading, can cost you an opportunity. Cross Chain Bridges fix this. ETH How does a Cross-Chain Bridge work? Cross-Chain Bridges, like the , have changed the game, and are part of the reason why DeFi Summer, was DeFi Summer. Multichain Bridge They work as follows, users typically lock or burn digital assets on the original chain and unlocks or mints the digital assets on the new chain. The whole process is governed by smart contracts, and hence why bridged assets are referred to as “wrapped assets” — cosily bundled up in smart contracts. For example, lets say there’s a liquidity pool on a Solana-based Decentralised Exchange (DEX), that requires Wrapped Ethereum and some stablecoin as the LP. What would happen is I would take my ERC20 Ethereum to a bridge, lock it to receive some wETH — Wrapped Ethereum — as sort of IOU which I can then move freely around the Solana network and deposit into the liquidity pool with an equal amount of stables. Cross-Chain Bridge Mechanisms There are 3 Cross-Chain bridge mechanisms that are used: and — Users burn assets on the original chain, and the equivalent assets are minted on the new chain. Burn mint — Users lock assets in a smart contract on one chain, and simultaneously, wrapped tokens will be minted on the target chain, with a 1:1 conversion. When reverting back, wrapped tokens on the destination chain are burned to unlock the original assets on the original chain. Lock and mint — Users lock assets on the first chain to unlock the same assets in a liquidity pool on the target chain Lock and unlock Issues with Cross-Chain Bridges No one is perfect, and bridges are not a person nor an exception. Bridges have been prime targets for hackers, for a few reasons. I will try to keep it simple here but it can get a bit technical so bear with me! As we have discussed, when bridging assets you lock/burn/deposit them on one end, to have them unlocked/minted/credited on the other. The notion that the asset conversion is guaranteed is actually incorrect, as the bridges don’t exist on a single blockchain — they in themselves are an external entity. As a result, no blockchain can verify the bridge! Verification is done by 3rd parties, the dynamic duo of Oracles and validators & custodians (usually in the form of a DAO or Smart Contracts). This added layer of reliance on 3rd parties destabilizes the trustless system and creates weak points which hackers can, exploit. and have, explains the vulnerabilities very well in his piece — highly recommend reading it. Ronal Thapa Is it Worth it to Use Cross-Chain Bridges? Cross Chain bridges give us a solution to the lack of interoperability, in a pretty seamless manner and save a lot of time when transferring assets between chains, and make it a lot easier to diversify your portfolio. Just make sure you are using a trusted bridge, have enough money for Gas and that the asset you are bridging is liquid enough on the target chain! Cross-chain bridges are good for linking 1 chain to another and facilitating that one-to-one network relationship but ultimately don’t . This is where Multichain comes into play. scale What is Multichain? When we speak about Multichain, we are referring to either: Multichain dApps Multichain Networks (or Modular Blockchains) What are Multichain Decentralised Applications (dApps) A Multichain Decentralised Application (dApp), is a project that has been deployed across multiple blockchains, specifically ones that share the same smart contract technology. For example, Ethereum, Polygon and Arbitrum all use the Ethereum Virtual Machine (EVM) — we call these EVM Compatible chains, and so multichain dApps can be built across those. Whilst Multichain applications are more widely accessible, allowing projects to scale with greater ease, there is still a widespread User Experience issue, for the most part, users are expected to switch networks on wallets when depending on where they are using the app, and for newcomers, it can pose as a severe roadblock. Moreover, having an dApp spread over multiple networks can lead to fragmented liquidity — which can severely harm the user experience further. The ideal state would be that you can connect wallets to multiple networks simultaneously, and access liquidity across all networks the dApp is built on. Seamless access. What are Multichain and Modular blockchains Often referred to as Modular Blockchains, Multichain networks are blockchains that have multiple, separate chains broken down into “layers” to perform different asks. This differs vastly from the general Layer 1 Blockchain — which for the most part uses a Monolithic structure. Think about it a bit like outsourcing. If the Blockchain was a company, a “monolithic” company would do everything in-house, but a “modular” company would outsource tasks to specialists Understanding Blockchain architecture can be tricky, but . ZebPay have done a good job of explaining it Benefits of Multichain and Modular Networks The benefits of Modular blockchain/Multichain networks are similar to those of Layer 2's Scalability — allowing specific chains to carry out specialised tasks brings greater efficiency and scalability to the overall network Security — Modular blockchains have shared security, which makes deploying new blockchains like rollups don’t require bootstrapping a new validator set, and means that new chains added to the network can benefit from the existing security. Lower Costs — Rollup SDKs, will not only help facilitate the low-cost creation of new blockchains, by providing a way to bootstrap without needing a consensus mechanism, large validator set, or token distribution. Super neat. What exactly is Omnichain and Layer 0? There is a lot of confusion as to what Omnichain/Layer 0 actually is. Most pieces I read threw around abstract thoughts and ideas of seamless interoperability and generic definitions for the implication of the prefix omni, without really hitting what we really mean. Looking back at what Multichain is, we mentioned that the dApps and networks had to be compatible, ie use the same smart contract technology — such as the Ethereum Virtual Machine. Omnichain is connecting all chains — regardless of their smart contract technology — by building a base layer (Layer 0) where all other networks and dApps can be situated on top of. A mega-multichain ecosystem that does not discriminate. With all these different layers and chains it can get tricky to visualise, so here's a simple way to think about it — The City analogy: Layer 0 — The main infrastructure (sewers, electricity grid, highways) Layer 1 — The Counties/States Layer 2 —Cities/Towns dApps — Stores and attractions Although this is quite simplified, it should give a slightly better idea as to how the system comes together. dApps can be built on Layer 1’s and not on Layer 2’s, and vice versa. For example, a dApp can be built and accessed on Polygon, but not accessible via Ethereum, and same goes the otherway round. The rise of Layer 0 and Omnichain brings us ever closer to a seamless web3 experience, with complete interoperability, minimal fragmentation and a much easier user experience. Projects like LayerZero, Polkadot and Cosmos all fall into this Layer 0/ Omnichain infrastructure category and are pioneering the future and mass adoption of blockchain infrastructure. Crosschain, Multichain and Omnichain all play their parts in the wider web3 world, and as we discussed, are all very different. I hope this piece cleared up the confusion!

Omnichain vs Multichain vs CrossChain: What Are They?

Omnichain vs Multichain vs CrossChain: ¿Qué son?

Omnichain vs Multichain vs CrossChain : qu'est-ce que c'est ?

ओमनीचैन बनाम मल्टीचैन बनाम क्रॉसचैन: वे क्या हैं?

オムニチェーン vs マルチチェーン vs クロスチェーン: それらは何ですか?

Omnichain vs Multichain vs CrossChain: O que são?

Omnichain vs Multichain vs CrossChain: Chúng là gì?

Omnichain vs Multichain vs CrossChain：它们是什么？

The Forms of Erotic Symbolism are Simulacra of Coitus

reating and deploying your own tokens on the internet is too easy. Blockchain and Smart Contracts have made it possible. Yes, you heard that right. You can deploy your own tokens on the internet. And that too without creating a whole new blockchain like Bitcoin or Ethereum. C These Tokens are just a piece of code running on top of a blockchain. Here’s a on blockchain. quick primer As a part of my learning I started learning about token standards and the problem I faced was the lack of resources where you can find everything about a token standard. Not a single resource was containing everything about a token standard.ERC20 was easy so it didn’t take much time. But ERC721 and ERC1155 took too much time to gather information and put them all together. Yes, it was easy to import Openzeppelin contracts and create the tokens but you will only learn the concepts if you practice all by yourself. So, just read these posts and start developing and deploying your tokens. Why am I writing this? Let’s get started with tokens. Prerequisites knowledge of solidity language and how it works (deployment and interaction). Knowledge about interfaces. (Here’s a handy ) resource Basically, tokens are a type of cryptocurrency that runs on top of a blockchain with some special use cases, for example, you can create tokens to fund your projects which are called ICO(Initial Coin Offering) similar to the share market, or you can also use tokens to assign a particular digital asset which has a specific value, apart from this, tokens can be used to represent ownership for some kind of data. They are also being used in governance, how? The person holding a specific amount of token of a company gets the privilege to vote for the company’s decisions. And there are many more use cases. The only thing you need is a Smart Contract deployed on a blockchain. Now there is a problem with interoperability, as there are billions of people with different ideas so it will become very difficult to utilize those tokens if every person is creating a new kind of token. This is because every token is nothing but a smart contract running on the blockchain, and smart contracts are codes written by developers. And different developers might implement the code in different ways. There would be chaos all over the network. Because the wallet providers and exchanges will have to write custom code to talk to different contracts with different kinds of functionality. Simply put, it’s impossible to write custom code for each contract individually. To overcome this we have token standards. ERC Ethereum Request for Comments ERC means Which helps the Ethereum environment to set rules or standards for the application layer of Ethereum Blockchain and make it more secure and scalable. Don’t get confused between ERC and EIP, EIPs are the proposals for core Ethereum functions and ERC is for the application layer. ERCs are a part of EIPs. . Ethereum Request for Comments. Learn more ERC token standards have a set of predefined rules that the developer should strictly follow while developing a token. There are different token standards as per demands. And they all have different sets of rules. Token standards give you an interface that you must implement when developing the respective token contract. You can add other functionalities also as per your demand but the standard interface should be implemented. Different ERC Standards There are lots of different ERC token standards out there but we will talk about some most popular and more commonly used ones. Which are . There are many more standards that are being proposed to improve the old ones with backward compatibility, we will talk about them on the go. ERC-20, ERC-721, and ERC-1155 ERC-20 — Fungible TokensERC-721 — Non-Fungible TokensERC-1155 — Both Fungible and Non-Fungible Tokens(Also semi-Fungible) Don’t know the difference between Fungible and Non-Fungible? Let’s learn. tokens can be defined as interchangeable, which means if you and I have 100 tokens, then we can exchange them and nothing will change. No profit no loss. Everything will be the same as before. Similar to any fiat currency like Dollars, Euros, Rupees, etc. Fungible tokens( ) are just the opposite of this. Which means every token is different from the other one. Every token is unique. Because Non-Fungible tokens are not only the representation of digits but they have external assets assigned to them, for example, any image, painting, ticket for a concert, music file, game collectibles, and many more things. This is why they are unique. Non-fungible NFTs The first standard to be proposed on the Ethereum network which is the most famous and basic one that comes to everyone’s mind when we talk about the token standard is the token standard. ERC-20 ERC-20 ERC-20 token standard was proposed in 2015 for fungible tokens. Fungible means interchangeable i.e. every token is the same as another token. This standard has nine functions and two events that should be implemented while creating an ERC-20 token. ERC-20 has the following functionalities: transfer tokens from one account to another. get the current token balance of an account. get the name, decimal, total supply, and symbol of the token available on the network. approve whether a number of tokens from an account can be spent by a third-party account. Let’s have a look at the ERC-20 interface. ERC20 Interface pragma solidity 
^0.8.0;
  interface IERC20 { 
      event Transfer(address indexed from, address indexed to, uint256 value); 
      event Approval(address indexed owner, address indexed spender, uint256 value); 
      function totalSupply() external view returns (uint256); 
      function balanceOf(address account) external view returns (uint256); 
      function transfer(address to, uint256 amount) external returns (bool); 
      function allowance(address owner, address spender) external view returns (uint256);
      function approve(address spender, uint256 amount) external returns (bool);
      function transferFrom(address from, address to, uint256 amount) external returns (bool);
  } First, we will see the functions. The first three functions, which are the , , and are considered to be optional and not included in the interface of an ERC20 contract. But they are really important and we can’t ignore them. name() symbol() decimal() The function should return the name of the token which is stored in a state variable. 1. name() function name()public view returns (string); The function should return the abbreviation of the token and this is also stored in a state variable. 2. symbol() function symbol()public view returns (string); is the important one to notice because solidity doesn’t support floating numbers and in order to perform transactions with values like 1.5, 2.4, etc., we have to break the number into lower denominations. Remember how the ether token can be broken into lower denominations like Gwei, Finney, and Wei. Normally we assign 18 decimals points and it is also recommended to do so. 3. decimals() function decimals()public view returns (uint8); This function should return the total amount of tokens in the market. Total supply of a token should only be affected by two functions, minting or burning. Minting means supplying newly created tokens and burning means destroying the tokens. We will talk about both of these later. 4. totalSupply() function totalSupply()public view returns (uint256); takes an address as an argument and returns its token balance. How does it know about my balance?We define a mapping inside our contract which keeps track of our balance, every time there is a transaction of tokens this mapping should be updated as this would be the only source of balance.This is what the mapping looks like: 5. balanceOf () mapping(address => uint ) internal balance; This function just returns the value from mapping. balanceOf function balanceOf(address _owner)public viewreturns (uint256 balance); is the function used to send tokens from one address to another. Takes an to which tokens are supposed to be sent and a which is the number of tokens to be sent, as arguments. And it should deduct the tokens from and add the amount to the recipient. How do the deduction and addition work? As I said earlier about the mapping. We simply decrease and increase the number of tokens in the mapping. 6. transfer() address uint msg.sender balance function transfer(address _to, uint256 _value)publicreturns (bool success); does the same thing as the function but there is a difference. This function is used to send tokens from one address to another address by a third address. How can someone spend my tokens? Is it safe? Yes, because any address can only spend your token if you have approved it to do so. How do we do it? That’s what the next function is about. 7. transferFrom() transfer function transferFrom(address _from, address _to, uint256 _value)public returns (bool success); 8. is used to approve any account to spend tokens from the account that is approving it. It takes two arguments first is the address of the spender and the second is the value of tokens that the spender is allowed to spend. We then update the nested mapping with this input. Which mapping?The mapping for approval is written like this: approve() mapping (address=> mapping (address => amount)) internal allowed; function approve(address _spender, uint256 _value)public returns (bool success); 9. is used to check the remaining tokens for the approved address to spend. It simply returns the data reading from the mapping. allowance() allowed function allowance(address _owner, address _spender)public view returns (uint256 remaining); These were the functions to be defined while creating an ERC20 token. Apart from these, we have two events that must be triggered at the desired times. They are: Every time there is a transfer of tokens from one account to another, this event should be triggered. It’s pretty obvious that this should emit inside the functions transfer and transferFrom. But there are two more functions at the time of implementation where this event is emitted. and functions. We will talk about these in a while. For now, just remember when emitting this event in a function, the sender address should be zero address, and in a function, the receiver should be zero address. Zero address looks like this: In solidity means this zero address. Transfer: Mint burn mint burn 0x0000000000000000000000000000000000000000 address(0) event Transfer(address indexed _from, address indexed _to, uint256 _value); This event should be triggered inside the function, every time someone approves any address. Approval: approve event Approval(address indexed _owner, address indexed _spender, uint256 _value); Every ERC20 token should implement these functions in the contract. Have a look at this simple implemented smart contract. // SPDX-License-Identifier: MIT

pragma solidity ^0.8.0;

interface ERC20Interface {

function allowance(address tokenOwner, address spender) public virtual view returns (uint remaining);
function balanceOf(address tokenOwner) public virtual view returns (uint balance);
function totalSupply() public view virtual returns  (uint);
function transferFrom(address from, address to, uint tokens) public virtual returns (bool success);
function transfer(address to, uint tokens) public virtual returns (bool success);
function approve(address spender, uint tokens) public virtual returns (bool success);

event Transfer(address indexed from, address indexed to, uint tokens);  
event Approval(address indexed tokenOwner, address indexed spender, uint tokens);  
event Supply(address indexed to, uint indexed amount, uint remainingSupply);  

}

contract Token is ERC20Interface  {
string public name;
string public symbol;
uint8 public decimals;
uint256 public _totalSupply;
uint public maximumSupply;
address public owner;

mapping(address => uint) private balances;  
mapping(address => mapping(address => uint)) private  allowed;  

constructor()  {  
    name = "MyFirstToken";  
    symbol = "MFT";  
    decimals = 18;  
    _totalSupply =  5000000 * 10**18;  
    maximumSupply = 10000000 * 10**18;  
    owner= msg.sender;  

    balances[msg.sender] = _totalSupply;  
    emit Transfer(address(0), msg.sender, _totalSupply);  
}  
  
function  remainingToken() public view returns (uint remainingSupply) {  

    return ( maximumSupply - _totalSupply);  
}  


modifier ownable ()  {  
    require (msg.sender== owner," only owner can perform this");  
    _;  
}  

function totalSupply() public override view returns (uint) {  
    return _totalSupply ;  
}  

function balanceOf(address tokenOwner) public override view returns (uint balance) {  
    return balances[tokenOwner];  
}  

function allowance(address tokenOwner, address spender) public override view returns (uint remaining) {  
    return allowed[tokenOwner][spender];  
}  

function approve(address spender, uint tokens) public override returns (bool success)  {  
    allowed[msg.sender][spender] = tokens;  
    emit Approval(msg.sender, spender, tokens);  
    return true;  
}  

function transfer(address to, uint tokens) public override returns (bool success) {  
    balances[msg.sender] = (balances[msg.sender] -= tokens);  
    balances[to] = (balances[to] += tokens);  
    emit Transfer(msg.sender, to, tokens);  
    return true;  
}  

function transferFrom(address from, address to, uint tokens) public override returns (bool success) {  
    require(balances[from] >=tokens, "You don't have enough tokens");  
    require(allowed[from][msg.sender] >=tokens, "You are not allowed to send tokens");  
    balances[from] = (balances[from] -= tokens);  
    allowed[from][msg.sender] = (allowed[from][msg.sender] -= tokens);  
    balances[to] = (balances[to]+= tokens);  
    emit Transfer(from, to, tokens);  
    return true;  
}  

function mint (address to ,uint amount) public ownable {  
   require(_totalSupply + amount <= maximumSupply,"You are exceeding the maximum supply");  
   balances[to] += amount;  
   _totalSupply += amount;  
   emit Supply(to,amount,remainingToken());  
}  

function burn (uint amount) public {  
    require(balances[msg.sender] >= amount, "not enough balance to burn");  
    balances[msg.sender] -= amount;  
    emit Supply(msg.sender, amount, remainingToken());  
} } This is a really simple implementation where you can see the contract token inherits from the interface and implements every function defined inside the interface.Notice there is two extra functions and . mint burn MINT The function is for minting new tokens. When you see the code inside it, you will notice that it increases the balance of any address. Which means there are new tokens being minted to that wallet. But why do we emit the transfer event here? This is because minting is considered as a transfer of tokens from the zero address to the given address. mint BURN Now, what about the function? The function really is a transfer of tokens but the recipient is always a zero address. Why so? Zero address is being used as a black hole in Ethereum, which means it’s unlikely to guess the private key of the zero address. Let’s not be too much technical here, just get the point that whenever you need to destroy some token meaning remove the token from the market you send it to this address, and boom, it’s gone forever. nobody can access those tokens now. This is the reason zero address holds tokens worth millions of dollars. burn burn That’s pretty much it about the ERC20 token standard. This is really simple and easy. But this is only for fungible tokens, what about the non-fungible tokens NFTs? ERC-721 is the standard for NFTs. Let’s talk about this in the next post. Also published . here

Understanding Token Standards in Ethereum Part - I (ERC20)

Manifest Dream Content and Latent Dream Thought

This is the last part of the debugging series, to learn the rest you'll need to get or . the book the course One of the most frequently asked questions I receive is: can we do these things in VS Code? The answer is unfortunately no. But I elaborate on the debugging capabilities of VS Code in . I'll do a blog post that covers that next week. this video Below is the last video in the series: https://www.youtube.com/watch?v=ImOmu4GHOls&embedable=true Transcript Welcome back to the ninth part of debugging at scale where we really know the quality of your code. Remote debugging doesn’t always deal with a remote machine, we often need it when debugging into Kubernetes or Docker. We’ll delve more into that later, but for now, we’ll discuss the basic mechanics. How to connect, how to make it slightly less vulnerable to security attacks, and then we’ll discuss the problems of remote debugging. The Connection and Command Line We’ll start with a discussion around the connection. We first need to run the process that we’ll connect to remotely. To do that, we need to run a command similar to this one. Notice that this is a simplified version; in many cases, the argument should be embedded in configuration files. When you inspect your maven or gradle files, you might see many of the arguments listed here. This is how these things work under the hood. Let’s go over the command and break it down piece by piece to see that we understand it correctly. The first part is the launch of the Java command line. This is pretty obvious. We need quotes in bash since there’s a star at the end of the line, and bash wants to expand it. Without this quote, the command won’t work properly. Agent lib is the system that loads the native library wiring directly into the virtual machine, and JDWP is the Java Debug Wire Protocol. This is the underlying networking protocol used to communicate between the debugger and the running process. It’s a high-level protocol, which means it can be implemented on top of various transports. Typically, it’s implemented over TCP sockets, but it’s the same protocol we used to debug devices directly. You don’t need to know too much about JDWP, but the concept is simple, you send commands and can query the system. That’s what the IDE does for you. When you add a breakpoint, the IDE sends a JDWP command to add a breakpoint at the given location. When the breakpoint is hit, JDWP sends back an event to the IDE indicating that. The IDE can then query the details about the current environment, stack, variables, etc. In this case, we transfer the details via a server socket. We can use dt_shmem which stands for shared memory as the wire protocol. This is faster and useful for processes that have access to a shared memory area. This is actually pluggable, and you can build your own JDWP transport. This isn’t useful usually but speaks to the power and flexibility of the API. We can optionally suspend the virtual machine on launch if you want to debug something right from the start. I’ve set this to no which means the VM will start running right away. If you set it to yes with the letter y, the VM will pause on launch and wait for the JDWP connection. This is the address and port we are listening on. In this case, I allow anyone to connect on port 5005. I can limit this to localhost only by changing the star character. This is probably the better approach, although it won’t make the protocol fully secure. This is the rest of the command for the class we’re running. Typically, you would have something more substantial here. In this case, I’m just running the PrimeMain class. To start debugging, we need to edit the run configuration in IntelliJ. Connecting From IntelliJ/IDEA Next, we need to locate a configuration for remote debugging. Once I select that, we can add it. Notice it’s pre-configured with the defaults such as port 5005. I give the new run configuration a name, and we’re ready to go with debugging the app. Notice there are many options to tune here, but we don’t need any of them. Also, check out this area right here. Seems familiar? That’s the exact line we discussed before. The IDE is showing us how to set up the command line for the remote process. This lets us verify that we entered everything correctly. We now have a new Debug Remote run configuration. We can switch to a different configuration from the same location. But when we want to do remote debugging, we need to toggle it here. Next, we need to press the debug button to run this command. We are now instantly connected to the running process. Once that is done, this feels and acts like any debugger instance launched from within the IDE. I can set a breakpoint, step over, inspect variables, etc. So why do it? In some cases, running the server locally in the IDE is impractical. A good example would be debugging a container on your own machine. That might not be trivial. Security Implications of JDWP Calling JDWP insecure is inaccurate. That would be like putting your house keys and home address wrapped in a nice gift wrapping with an itemized list of your valuables sorted by value in front of your house. This is an open door. An open door isn’t a security vulnerability. It’s an open door! JDWP is very insecure when used remotely. Locally, on your own machine, it isn’t a problem, but it has almost no security protections. There’s no solution for that. But there’s a very partial workaround for tunneling it over SSH. This is relatively trivial. Just use this command to open a tunnel between the remote machine to your local machine. For both sides, it will seem like local debugging. So, the example I showed before of connecting to a local host server, would work perfectly with this remote host as SSH will move all the packets back and forth. Securely. We can’t ssh into a Kubernetes container, but we can port forward which is almost identical. We can do something similar to this command to forward the port from the given pod to the local machine and vice versa. Same idea as SSH tunneling but appropriated to the Kubernetes world. Dangers of Remote Debugging In this final section, I want to talk about the dangers of remote debugging in production. Breakpoints break seems obvious. That’s what they’re here to do. But if we run on a server, we block it completely by mistake. We can use trace points. As I said, they’re great. But they are no replacement for breakpoints, and an accidental click in the gutter can literally stop your server in its tracks. JDWP effectively allows remote code execution. It lets you access all the bytecode of the app which is effectively the same as giving access to your full source code. It lets attackers do almost anything since it wasn’t designed with security in mind. We need to relaunch the application with debugging enabled. That means killing the running process and starting it over again. Disconnecting existing users, etc. That isn’t great. Some operations in the debugger require more than one step in terms of the protocol. As a result, you could send a request to the debuggee, lose your connection, and the debuggee could be stuck in a problematic state. This is an inherent limitation of the JDWP protocol and can’t be worked around in a standard debugger. The problem is that even unintentional actions can demolish a server. A simple conditional breakpoint that invokes a method as part of the condition can demolish server performance and crash it. JDWP effectively allows remote code execution. It lets you access all the bytecode of the app which is effectively the same as giving access to your full source code. It lets attackers do almost anything since it wasn’t designed with security in mind. Imagine placing a breakpoint where the user password is passed to authentication… If JDWP is open for your server, a member of your team might use that, and you will never know! There’s no tracking at all! 60% of security hacks happen from within the organization. If your company does remote debugging, they have no way of knowing whether an employee used that to manipulate the application state or siphon user details. There’s no tracking or anything. This can be in violation of various rules and regulations since it might expose personal user data. Remote debugging into production can trigger liability risks. I discuss some of the solutions for those problems both in low-level tooling and in higher-level observability solutions. This is covered in the book and in the full course. Final Word With this, we finished the first part of the course. If you want to check out the full course, go to to learn more… The next video covers the strategies for debugging and the science of debugging. If you have any questions, please use the comments section. Thank you! debugagent.com Photo by on Eric Muhr Unsplash

The Dangers and Pitfalls of Remote Debugging: What You Need to Be Careful Of

We’ll understand overflow and underflow vulnerability of solidity by Solving Ethernaut’sTOKEN Challenge. If you haven’t solved the Ethernaut Challenges already, but are planning to try it out, this might be a spoiler. Come back after solving the Token Challenge When it comes to smart contracts, even a small bug in the code can cost you millions of dollars. So, it becomes essential to audit smart contracts & make sure there is no vulnerability in the code that can be exploited by a hacker. Integers in Solidity Ethereum Virtual Machine specifies a fixed range for all integers. An integer variable can only store a certain range of numbers. uint8 => range is 0 to 255, i.e. 8 bits or 1 byte or 1 byte (lowest size range) uint256 => range is 0 to 2²⁵⁶- 1, i.e. 256 bits or 32 bytes (highest size range OVERFLOW A number is too big & the part that exceeds the maximum range is counted from zero again. so we end up with a number that is smaller than what we started with. Solidity How does solidity handle a number that is bigger than this range? It circles back to where it started, i.e. zero, and starts again from there. exceeding the maximum number by 1 would get us to 0, exceeding the max number by 2 would get us to 1, exceeding the max number by 3 would get us back to 2 & so on. When a number overflows in solidity, it doesn’t give any warnings or errors. It simply doesn’t care. UNDERFLOW A number is smaller than the minimum range, so it starts counting back from the maximum number, and we end up with a number greater than what we started with. (It's the opposite of overflow) Solidity How does solidity handle a number that is smaller than this range? It wraps around & jumps to the highest number of the range, i.e. 2²⁵⁶ — 1. One number less than the minimum number would get us to 2²⁵⁶-1 (max number). Two less than the min number would get us to 2²⁵⁶-2, & so on. And like for overflows, when a number underflows in solidity, it again doesn’t give any warnings or errors. PREVENTION Use vetted SafeMath libraries for arithmetic operations consistently throughout the smart contract system. It throws an error whenever there is an overflow or an underflow. Analyzing Ethernaut’s : TOKEN Challenge THE CHALLENGE : The goal of this level is to hack the basic contract token below. You are given 20 tokens to start with & you will beat the level if you somehow manage to get your hands on any additional tokens. Preferably a very large amount of tokens First of all, it’s not a good practice to have floating point (^) caret in our pragma compiler. Make sure it is locked (like 0.6.0 ). Then we have two state variables — totalSupply & balances. Balances map addresses to units, showing the funds each address holds. (Line 6) *Note: unit doesn’t have a size mentioned. In solidity, this is uint256 by default. And we have a constructor that takes a value (_initialSupply) & stores it in a state variable (totalSupply), which will be the funds mapped to the address of the contract deployer. (balances[msg.sender]).The transfer function takes an address(_to) we gonna transfer the fund & a uint(_value) for the funds we transfer. The function returns a bool (true) when certain requirements are met. The required function makes sure the funds (_value) we transfer is less than or equal to what we actually have. If our address has the funds, that amount is subtracted from our address & added to the address we sent the funds to (_to). At last, we have a balanceOf function which takes an address & shows us the funds it holds. Checkout out the challenge in . Ethernaut Solving Ethernaut Level 5: TOKEN Can you find the flaw in the above smart contract? Let’s go to the transfer function again & look carefully at the require(). We are given a total balance of 20 tokens in our address. If we transfer 15 tokens (spent less than our total balance of 20), we’ll be left with 5 tokens in our address. If we transfer 20 tokens (spent equal to our total balance of 20), we’ll be left with 5 tokens in our address. But what if we transfer more than our total balance? What If we transfer 25 tokens (more than our total balance of 20), how will the smart contract behave & how many tokens will we have in our address (if any at all)? 20 – 25 = -5. The token balance comes out to be -5. But as we know, from line 6, the balance an address holds should be a uint256 (i.e. unsigned integer, it cannot have a negative sign). So after reaching zero, instead of going to -1, it would wrap around & continue counting backwards from there going to 2²⁵⁶ –1, 2²⁵⁶ –2, 2²⁵⁶ –3, 2²⁵⁶ –4 & finally reach 2²⁵⁶ –5. This means now the balance left in our address after spending 25 tokens would be. (Remember our Underflow vulnerability from before? ) Now if you remember our Ethernaut Challenge, we were told to take out and get as many funds as we can. As the maximum number in the uint256 range is 2²⁵⁶ –1, to get that as the balance left in our account, we must spend one more than our total balance of 20, i.e. 21. Real Life Example In 2018, a blockchain security startup known as PeckShield discovered an unusual transaction. The team has set up a system to analyze ERC20 token transfers & send out alerts whenever it discovers anomalous behavior. The team was greeted by one of these alerts on the 22nd of April (it involved Beauty Chain). PeckShield began looking into the code for the underlying smart contract, which indicated that the transfer involved exploiting a vulnerability that had previously been unknown in the contract. The company named the vulnerability batchOverflow, which involves an integer overflow at its heart. The vulnerable part of the code was the batch transfer. To know more about the details of this incident, you can refer to PeckShield’s blog.

Decoding Overflow And Underflow Vulnerability in Smart Contracts

In this article, we will analyze the interesting points of the Fragment API, I think that it will be of interest to all developers who develop an application for Android. First, you need to add dependencies: dependencies {    
	def fragment_version = "1.5.4"
	implementation "androidx.fragment:fragment-ktx:$fragment_version"
} Fragment-ktx FragmentManager Now you can describe transactions in a DSL style and the functions and or are called under the hood: beginTransaction() commit() commitAllowStateLoss() fun FragmentManager.commit(
  allowStateLoss: Boolean = false, 
  block:  FragmentTransaction.() -> Unit
) Example: fragmentManager.commit {
  // transaction
} FragmentTransaction Added replacement for method overloads. A similar extension has been added for : FragmentTransaction.add(Int, Class<out Fragment>, Bundle?) FragmentTransaction.replace() fun <reified T: Fragment> FragmentTransaction.add(
  containerId: Int, 
  tag: String? = null, 
  args: Bundle? = null
): FragmentTransaction

fun <reified T: Fragment> FragmentTransaction.replace(
  containerId: Int, 
  tag: String? = null, 
  args: Bundle? = null
): FragmentTransaction Example: fragmentManager.commit {
  val args = bundleOf("key" to "value")
  add<FragmentA>(R.id.fragment_container, "tag", args)
  replace<FragmentB>(R.id.fragment_container)
} Transaction optimization Optimization is a pretty important thing. To figure out how FragmentManager can do everything for us, let's try to optimize transactions by hand. fragmentManager.commit {
  add<FragmentA>(R.id.fragment_container)
  replace<FragmentB>(R.id.fragment_container)
  replace<FragmentC>(R.id.fragment_container)
} How to speed up a transaction? During the most complex technical analysis, we see that, following its results, the user will see . We are simple people and just throw out the extra two actions, immediately showing . Another example is with two transactions running one after the other: FragmentC FragmentC // 1
fragmentManager.commit {
  add<FragmentA>(R.id.fragment_container)
}

// 2
fragmentManager.commit {
  replace<FragmentB>(R.id.fragment_container)
} In this case, we could abort the addition of and immediately add . We cannot do this, but the problem is rather theoretical. All of the above FragmentManager can do on its own. We just need to allow it by adding to the transaction we want to optimize. FragmentA FragmentB setReorderingAllowed(true) fragmentManager.commit {
  setReorderingAllowed(true)
  add<FragmentA>(R.id.fragment_container)
  replace<FragmentB>(R.id.fragment_container)
  replace<FragmentC>(R.id.fragment_container)
} In the second place, you need to set the focus in the first place, because it is her permission to interrupt, and the second, in turn, must be fully controlled: // 1
fragmentManager.commit {
  setReorderingAllowed(true)
  add<FragmentA>(R.id.fragment_container)
}

// 2
fragmentManager.commit {
  replace<FragmentB>(R.id.fragment_container)
} In fact, we allow the to behave lazily and not execute unnecessary commands, which gives some performance gain. Moreover, it helps to handle animations, transitions, and back stack correctly. FragmentManager It is worth remembering that an optimized can: FragmentManager do not create a fragment if it is replaced in the same transaction; interrupt the life cycle at any time before , if a transaction to replace the added fragment has begun; RESUMED cause of the new fragment to be called before of the old one. onCreate() onDestroy() During a transaction, there are several ways to manage the life cycle of a fragment, in some cases, this may be useful. Change visibility We can hide and show a fragment without changing its lifecycle state. This behavior is similar to and . View.visibility = View.GONE View.visibility = View.VISIBLE We can just hide the container. This is true, but hiding the container in the back stack will not work, and a transaction with a similar command is easy. To hide a fragment from prying eyes, just call the method: FragmentTransaction.hide(Fragment) fragmentManager.commit {
  setReorderingAllowed(true)
  fragmentManager.findFragmentById(R.id.fragment_container)?.let {  
    hide(it) 
  }
} To show it again, you need to call the method: FragmentTransaction.show(Fragment) fragmentManager.commit {
  setReorderingAllowed(true)
  fragmentManager.findFragmentById(R.id.fragment_container)?.let { 
    show(it) 
  }
} Destroying the View We can destroy the Fragment's View, but not the itself, by calling the method. As a result of such a transaction, the fragment will enter the state: Fragment FragmentTransaction.detach(Fragment) STOPPED fragmentManager.commit {
  setReorderingAllowed(true)
  fragmentManager.findFragmentById(R.id.fragment_container)?.let { 
    detach(it) 
  }
} To recreate the Fragment View, just call the method: FragmentTransaction.attach(Fragment) fragmentManager.commit {
  setReorderingAllowed(true)
  fragmentManager.findFragmentById(R.id.fragment_container)?.let { 
    attach(it) 
  }
} FragmentFactory In Fragments 1.1.0, we can control the creation of fragment instances, including adding any parameters and dependencies to the constructor. To do this, it is enough to replace the standard implementation of with our own, where we are our kings and gods. FragmentFactory fragmentManager.fagmentFactory = MyFragmentFactory(Dependency()) The main thing is to have time to replace the implementation before the needs it, that is, before the first transaction and restoring the state after re-creation. The sooner we replace the bad implementation, the better. FragmentManager For Activity, the best scenario would be to replace: before ; super.onCreate() in the block. init Fragments do not immediately have access to their . Therefore, we can only perform the substitution between and inclusive, otherwise, we will see terrible red text in the logs after launch. FragmentManager onAttach() onCreate() But it's important to remember that is the through which the commit was made. parentFragmentManager FragmentManager Therefore, if you previously replaced in it, you do not need to do this a second time. FragmentFactory Now let's figure out how we can implement our factory. We create a class, inherit from , and override the method. FragmentFactory instantiate() class MyFragmentFactory(
  private val dependency: Dependency
) : FragmentFactory() {
  
  override fun instantiate(classLoader: ClassLoader, className: String): Fragment {
    return when(className) {
      FirstFragment::class.java.name -> FirstFragment(dependency)
      SecondFragment::class.java.name -> SecondFragment()
      else -> super.instantiate(classLoader, className)
    }
  }
} We get a as input, which can be used to create a , and is the full name of the desired fragment. We determine which fragment we need to create and return based on the name. If we do not know such a fragment, we transfer control to the parent implementation. classLoader Class<out Fragment> className This is what looks like under the hood of : super.instantiate() FragmentFactory open fun instantiate(classLoader: ClassLoader, className: String): Fragment {
  try {
    val cls: Class<out Fragment> = loadFragmentClass(classLoader, className)
    return cls.getConstructor().newInstance()
  } catch (java.lang.InstantiationException e) {
    …
  }
} LayoutId in the constructor Let's remember how we learned to work with fragments. We create a class, create a markup file, and inflate it in : onCreateView() override fun onCreateView(
  inflater: LayoutInflater,
  container: ViewGroup?,
  savedInstanceState: Bundle?
): View? = inflater.inflate(R.layout.fragment_example, container, false) We've typed these familiar strings hundreds of times, but in version 1.1.0 of , the folks at Google have decided they won't take it anymore. They added a second constructor to fragments that take as input, so you no longer need to override . Fragments @LayoutRes onCreateView() class ExampleFragment : Fragment(R.layout.fragment_example) And under the hood, the same boilerplate works: constructor(@LayoutRes contentLayoutId: Int) : this() {
  mContentLayoutId = contentLayoutId
}

open fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?) : View? {
  if (mContentLayoutId != 0) {
    return inflater.inflate(mContentLayoutId, container, false)
  }
  return null;
} The less code we have to write, the better. If suddenly you have previously initialized the View in , it is more correct to use a special callback called immediately after . onCreateView() onViewCreated() onCreateView() override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
   button.setOnClickListener {
      // do something
   }
   // some view initialization
} Summary This article looked at the features and new features of creating Fragments and how you can pass LayoutId in the Fragment constructor. In the next part of the article, we will look at animations during the transition and closing of the Fragment.

Understanding Fragments in Android: Part 2

Random Reminiscences of Men and Events, by John D. Rockefeller is part of the HackerNoon Books series. You can jump to any chapter in this book here . Chapter I : THE PLEASURES OF ROAD PLANNING Chapter I. THE PLEASURES OF ROAD PLANNING Like my old friend, others may be surprised at my claim to be an amateur landscape architect in a small way, and my family have been known to employ a great landscape man to make quite sure that I did not ruin the place. The problem was, just where to put the new home at Pocantico Hills, which has recently been built. I thought I had the advantage of knowing every foot of the land, all the old big trees were personal friends of mine, and with the views of any given point I was perfectly familiar—I had studied them hundreds of times; and after this great landscape architect had laid out his plans and had driven his lines of stakes, I asked if I might see what I could do with the job. In a few days I had worked out a plan so devised that the roads caught just the best views at just the angles where in driving up the hill you came upon impressive outlooks, and at the ending was the final burst of river, hill, cloud, and great sweep of country to crown the whole; and here I fixed my stakes to show where I suggested that the roads should run, and finally the exact place where the house should be. "Look it all over," I said, "and decide which plan is best." It was a proud moment when this real authority accepted my suggestions as bringing out the most favoured spots for views and agreed upon the site of the house. How many miles of roads I have laid out in my time, I can hardly compute, but I have often kept at it until I was exhausted. While surveying roads, I have run the lines until darkness made it impossible to see the little stakes and flags. It is all very vain of me to tell of these landscape enterprises, but perhaps they will offset the business talks which occupy so much of my story. My methods of attending to business matters differed from those of most well-conducted merchants of my time and allowed me more freedom. Even after the chief affairs of the Standard Oil Company were moved to New York, I spent most of my summers at our home in Cleveland, and I do still. I would come to New York when my presence seemed necessary, but for the most part I kept in touch with the business through our own telegraph wires, and was left free to attend to many things which interested me—among others, the making of paths, the planting of trees, and the setting out of little forests of seedlings. Of all the profitable things which develop quickly under the hand, I have thought my young nurseries show the greatest yield. We keep a set of account books for each place, and I was amazed not long ago at the increase in value that a few years make in growing things, when we came to remove some young trees from Westchester County to Lakewood, New Jersey. We plant our young trees, especially evergreens, by the thousand—I think we have put in as many as ten thousand at once, and let them develop, to be used later in some of our planting schemes. If we transfer young trees from Pocantico to our home in Lakewood, we charge one place and credit the other for these trees at the market rate. We are our own best customers, and we make a small fortune out of ourselves by selling to our New Jersey place at $1.50 or $2.00 each, trees which originally cost us only five or ten cents at Pocantico. In nursery stock, as in other things, the advantage of doing things on a large scale reveals itself. The pleasure and satisfaction of saving and moving large trees—trees, say, from ten to twenty inches in diameter, or even more in some cases—has been for years a source of great interest. We build our movers ourselves, and work with our own men, and it is truly surprising what liberties you can take with trees, if you once learn how to handle these monsters. We have moved trees ninety feet high, and many seventy or eighty feet. And they naturally are by no means young. At one time or another we have tried almost all kinds of trees, including some which the authorities said could not be moved with success. Perhaps the most daring experiments were with horse-chestnuts. We took up large trees, transported them considerable distances, some of them after they were actually in flower, all at a cost of twenty dollars per tree, and lost very few. We were so successful that we became rather reckless, trying experiments out of season, but when we worked on plans we had already tried, our results were remarkably satisfactory. Taking our experiences in many hundreds of trees of various kinds in and out of season, and including the time when we were learning the art, our total loss has been something less than 10 per cent., probably more nearly 6 or 7 per cent. A whole tree-moving campaign in a single season has been accomplished with a loss of about 3 per cent. I am willing to admit that in the case of the larger trees the growth has been retarded perhaps two years, but this is a small matter, for people no longer young wish to get the effects they desire at once, and the modern tree-mover does it. We have grouped and arranged clumps of big spruces to fit the purposes we were aiming for, and sometimes have completely covered a hillside with them. Oaks we have not been successful with except when comparatively young, and we don't try to move oaks and hickories when they have come near to maturity; but we have made some successful experiments with bass wood, and one of these we have moved three times without injury. Birches have generally baffled us, but evergreens, except cedars, have been almost invariably successfully handled. This planning for good views must have been an early passion with me. I remember when I was hardly more than a boy I wanted to cut away a big tree which I thought interfered with the view from the windows of the dining- room of our home. I was for cutting it down, but some other members of the family objected, though my dear mother, I think, sympathized with me, as she said one day: "You know, my son, we have breakfast at eight o'clock, and I think if the tree were felled some time before we sat down to table, there would probably be no great complaint when the family saw the view which the fallen tree revealed." So it turned out. About HackerNoon Book Series: We bring you the most important technical, scientific, and insightful public domain books. This book is part of the public domain. Rockefeller, John D. 2005. Essays on some unsettled Questions of Political Economy. Urbana, Illinois: Project Gutenberg. Retrieved May 2022 from https://www.gutenberg.org/files/17090/17090-h/17090-h.htm This eBook is for the use of anyone anywhere at no cost and with almost no restrictions whatsoever. You may copy it, give it away or re-use it under the terms of the Project Gutenberg License included with this eBook or online at www.gutenberg.org , located at https://www.gutenberg.org/policy/license.html.

THE PLEASURES OF ROAD PLANNING

What is So Good About the Ownership Economy?

¿Qué tiene de bueno la economía de propiedad?

Qu'y a-t-il de si bon dans l'économie de la propriété ?

स्वामित्व अर्थव्यवस्था के बारे में इतना अच्छा क्या है?

所有経済の何がそんなに良いのか?

O que há de tão bom na economia da propriedade?

Điều gì tốt về nền kinh tế sở hữu?

所有制经济有什么好处？

Working remotely means managing a lot of work, and to do this successfully efficient time management is key. I have compiled some productivity apps that will make your life as a remote worker easier and faster. In the following table, I shared some of the apps that will make your work more productive. App Name App description Website URL notion.so Notion is a workspace where we can create docs, wikis, tables, etc. You can export your work in PDF and other formats. notion.so wetransfer It is used to transfer data on the internet via unique links. wetransfer.com IlovePDF It is an online PDF editor that lets you merge, split, and convert PDF files. ilovepdf.com Webflow It is a no-code website builder used by designers and teams to create, collaborate on, and scale beautiful websites. webflow.com Zaiper Zaiper allows you to connect with different apps, automate your funnel, and streamline your business. zapier.com Grammarly It is a cloud-based typing assistant that checks spelling, grammar, punctuation, clarity, engagement, and delivery mistakes. grammarly.com Canva It is a platform for designing graphics for media, presentations, posters, documents, and other visual content. canva.com Pexels Pexels is the website where to find stock photos, royalty-free images & videos shared by creators. pexels.com Iconfinder Iconfinder is a search engine that searches for icons, 3Ds, and illustrations. iconfinder.com swimlanes It is a simple online tool for creating sequence diagrams. swimlanes.io Airtable Airtable is used to store the data in an excel sheet. We can use Airtable to collect data from different sources. airtable.com Stripe Payment Link It is used to create a payment link to sell online without a website. stripe-payments-links affinity.serif Alternative to Adobe Photoshop. It is a professional photo editing, page layout, graphic design, and illustration tool. affinity.serif.com remove.bg It is a tool to remove the background or used to extract an object from the image. remove.bg Typeform Create forms, surveys, and quizzes that people enjoy answering. typeform.com Getsharex It is used to screen capture, file sharing, and productivity tool. getsharex.com haikei.app Generate unique SVG design assets. haikei.app Balsamiq It is used for wireframes to design user interfaces for desktop software, website, mobile apps, etc. balsamiq.com You can contact me through if you would like to add other apps that help you with daily tasks. this form

18 Best Productivity Apps For Remote Workers

Have you heard about the Internet of Things and Big Data? They are two very trending technologies that have evolved independently for a long time but become interrelated over time. Nowadays, people use both these terms together while discussing IoT software solutions or applications. Technologies have already exceeded human imagination. A usual online graphic calculator available for use from any part of the world is many times more powerful than most computers in the 20th century. In 1976 there was a delivery of the first supercomputer system with more than 5 tons of the total weight of the mainframe! A modern game platform Sony PlayStation 5 that weighs 0,004 tons is more powerful. Cray The relationship between the Internet of Things and Big Data will impact all spheres of our lives no matter whether you are going to use them during the development of your next software project  or as a daily app. We agree with Shawn DuBravac, who wrote in his book about the new age of data: “ ” This is what will happen regardless of which road we take. In the article, we consider the Internet of Things and Big Data technologies and discuss how they are interrelated. Enjoy reading! Internet of Things and Big Data. Real-life Use Cases Let us start with real-life examples of IoT systems, where Big Data plays a significant role. The media focuses people's attention on the mass market side of the Internet of Things development, for example, wearable devices like smartwatches and fitness trackers. However, IoT possibilities are much wider than the functionality of these products, and IoT has a big thing to offer to businesses. Empowered by Big Data and other modern technologies, like cloud computing, nanotech, IoT systems can be implemented on all levels of business operations in existing companies and even lead to the emergence of new types of businesses that have never existed before. Below there are 3 awesome examples of the Internet of Things and Big Data technologies implementation in one system. Do you believe in miracles? Disney does believe. Source: wired.com Disney decided to use Big Data and the Internet of Things technologies to improve the personal experience of Disney parks. Disney developed , a colorful, silicone, waterproof wristband that can be used to unlock hotel rooms, enter theme parks, charge food and merchandise purchases. It also collects all sorts of data from visitors and uses it to reduce the waiting time in lines and prepare personalized surprises. Disney’s MagicBand Disney spent more than to develop a Magical Wristband, and nowadays, it is an indispensable element in the Disney Park magical experience. $1 billion Can Global Logistics be smart? With Big Data and the Internet of Things, definitely yes What if a company puts smart sensors in the transportation fleet and calibrates them to record all possible information during the delivery? Will that information be meaningful? The transportation and logistics company made it and then developed a smart logistics system called ORION based on Big Data collected from sensors. ORION uses advanced algorithms to create optimal routes for delivery drivers from the data supplied by customers, drivers, and vehicles. It also can alter the routes on the fly based on changing weather conditions or accidents. UPS How can the Internet of Things and Big Data Help Agriculture? The crops are vulnerable to damage from insects, disease, and other factors, while agricultural fields are too big for accurate monitoring by humans. Using drones, 3D video sensors, big data, and machine learning, the company enables proactive deep real-time crop observation to mitigate yield loss. Aker The system is set in two steps: first, drones place video sensors all over the fields. Second, sensors take pictures of crops and make accurate crop health and pest maps of the agricultural fields, allowing farmers to identify crop damage early and make necessary decisions quickly. Sensors continue to work and update maps in real-time. Aker platform supports more than 50 crop types, the downloading of scouting data offline, and allows sharing scouting reports. Big Data and the Internet of Things help farmers to decrease damage from pests and pathogens - it’s awesome! ‍ What are IoT and Big Data? is a system of interrelated physical devices that can collect and exchange data with other devices and systems over the Internet. A sensor that measures the temperature of the air at home and transfers that information to your smartphone is an element of an IoT system (we have a comprehensive article about ). The Internet of Things (or IoT) IoT architecture There are that IoT systems can achieve. 2 main goals is to provide data from sensors for further analysis by people to help them make the right decision later. For example, fitness trackers collect data regarding your physical activity during the day and advise whether you need to take a little walk in the evening. The first one is to provide data to the whole IoT system so the system can make real-time decisions. An example is a driverless car that is outfitted with sensors that collect information about the environment and pass it to the central processor. The system transfers information without any delay allowing the car to make a split-second decision on the road. Another goal Despite the COVID-19’s impact on the global supply chain, the Internet of Things continues to grow, expecting the number of connected IoT devices worldwide to reach 12.3 billion active devices in 2021. IoT showed the world what a fully interconnected world is. We are impressed! Source: Global IoT market forecast ‍ works with a very large set of structured and unstructured data of different types that is too massive to process using traditional techniques. Big Data Big Data comprises technologies that help to store, organize, and analyze massive volumes of information. of big data is to find patterns in large and unstructured data sets so people can make better decisions and strategic business moves. The main goal We found out what lies behind the terms Big Data and Internet of Things. But still, the way these two technologies work together is an open question. Let's clarify it. What is the Relationship between Big Data and Internet of Things? The amount of connected IoT devices has already exceeded the world population, and it continues to grow. To complicate things further, IoT today is more about machine-to-machine communication, rather than machine-to-human. That leads to a situation when IoT applications deal with an incredible amount of data that cannot be processed or even stored using traditional methods. “ ” - Dr. Patrick Wolfe, data scientist at the University College of London. The rate at which we are generating data is rapidly outpacing our ability to analyze it, “The trick here is to turn these massive data streams from a liability into a strength.” In other words, data from IoT devices is only useful when the analysis goes after data collection. So we should concern ourselves with a new question: “How can we learn from data?” And that question led to a tsunami of Big Data growth that features large-scale applications, an increased amount of machine-to-machine traffic, NoSQL solutions, geographically distributed server nodes and a large volume of collected data. Let’s find out how Big Data changes IoT systems. IoT systems include 4 main stages in the architecture that perform varied data manipulations: collection, transferring, filtering and pre-processing, analyzing. The synergy of Big Data and the Internet of Things impacted 3 out of the 4 stages. a massive amount of data within a massive IoT system developers use LPWA technology and MQTT, HTTP, and CoAP protocols. To transfer the data the only viable option is NoSQL solutions. Big Data processes a vast amount of unstructured data of different origins, content, and formats, which is an almost impossible task for a standard relational database. To store the data Big Data analytic software comes into play. Leveraging Big Data technology, businesses get an opportunity to uncover hidden patterns, correlations, market trends, etc. The analysis is what allows farmers to identify places with damaged corps, transportation companies to find effective delivery routes, and Disney to provide an unforgettable experience in Disney Park!
‍ To analyze At the end of the day, the only thing that matters is how we learn from data to build future-ready solutions. Conclusion IoT and Big Data synergy can lead us to new technological applications and complex industrial IoT systems. We are about to see innovations we can only dream of. As new applications enter the mainstream of our daily lives, and technology matures, even more ways to leverage the IoT and Big Data are bound to appear. FAQ Is it necessary to use Big Data while building an IoT system? No. IoT and Big Data technologies are interconnected but still independent of each other. If you have a smart TV, fridge, doorbell, or any other connected device they are a part of an IoT system. However, you don’t need Big Data to realize that you forgot to turn off the light in the bedroom or that your refrigerator is out of milk. Big Data is only needed when it comes to a large number of sensors and massive volumes of unstructured data. How big is the data in IoT? According to , the data volume of Internet of Things connections worldwide reached 13.6 zettabytes point in 2021. It's also expected to reach 79.4 zettabytes by 2025. Even assuming these predictions are half wrong, the numbers are still overwhelming! 1 zettabyte is equivalent to1021bytes (a terabyte is equivalent to 1012bytes). We have entered the new Age of data volume. Welcome to the . Statista Zettabyte Era Original post: SumatoSoft.com

IoT, Big Data and the Era of the Zettabyte

In this article, we are going to learn in JavaScript, as well as see the ways you can use them. higher-order functions The key feature of higher-order functions is that they can accept other functions as arguments and/or specify a function as a return value. Extraordinary functional methods like these are strong constructs available to you in JavaScript and other high-level languages like Python, Lisp, etc. The JavaScript function is a first-class object. There is the concept of in programming languages. This refers to the values that can be passed to a function, returned from a function, and assigned to variables or constants. These values include data of all types, such as numbers, strings, arrays, booleans, etc. first-kind (or class) objects One should take into account that the variable or constant itself does not fall under this concept, since only the data contained in the variable or constant is considered a first-class object. Against this background, the following statements will be correct: We can pass the first-class object to a function as an argument We can pass other functions to a higher-order function as an argument Let’s have a look at the example below: const function1 = () => {
    console.log("I'm the function1 result");
};

const function2 = (callback) => {
    console.log("I'm the function2 result");

    callback();
};

function2(function1);
// I'm the function2 result
// I'm the function1 result The function passed as an argument to a higher-order function is called callback. Here, we are passing as an argument to . acts as a callback and it is worth diving deeper into this. But prior to that, let's look at an example that doesn't use a callback: function1 function2 function1 const calculate = (x, y, operation) => {
    if (operation === 'subtract') {
        return x - y;
    } else if (operation === 'divide') {
        return x / y;
    }
};

console.log(calculate(10, 3, 'subtract'));
// 7 Suppose the above calculate function makes a part of a library like jQuery. In the current implementation, the function supports 2 types of calculations: division and subtraction. But what if we also need, for example, addition or multiplication operations? In this case, you will have to search for another library, since we cannot add the required calculation methods to the library. But there is another option, which lies in making the function more abstract. For this, we need to expose the functionality through a callback. calculate Let's add a callback to the example mentioned above. This will not only improve our code but also allow us to visually evaluate the callback features: // Library function
const calculate = (x, y, callback) => {
    if (typeof callback === 'function') {
        return callback(x, y);
    };
};

// Functions that we will pass as callback
const add = (x, y) => {
    return x + y;
};

const substract = (x, y) => {
    return x - y;
};

const multiplay = (x, y) => {
    return x * y;
};

const divide = (x, y) => {
    return x / y;
};

// We call the function from the library and pass the callback
console.log(calculate(12, 8, add));
// 20 Under this approach, we transfer not just a specific operation to the library but a function that implements this operation. And now it only takes to run it to get the result. Take a look at a real-life example: let’s sort the array by keys in ascending order using the method: sort() const someArray = [
    {
        key: 12,
        value: 'Hello',
    },
    {
        key: 14,
        value: 'Something',
    },
    {
        key: 13,
        value: 'World',
    },
];

someArray.sort((valueA, valueB) => {
    if (valueA.key < valueB.key) {
        return -1;
    } else {
        return 1;
    }
});

someArray.forEach((value) => {
    console.log(`${value.key} ${value.value}`)
});
// 12 Hello
// 13 World
// 14 Something If we need to sort the array in descending order by values, the code would look like this: someArray.sort((valueA, valueB) => {
    if (valueA.value > valueB.value) {
        return -1;
    } else {
        return 1;
    }
});

simpleArray.forEach((value) =>
    console.log(`${value.key} ${value.value}`)
);

// 13 World
// 14 Something
// 12 Hello In the above examples, we used simple functions. However, when they are passed as arguments to other functions, they can take part in more complex functions in an unexpected way. I hope this article was helpful and you will use callbacks more frequently in your projects.

Higher-Order Function in JavaScript with ES6 Examples

In one of my projects, I use the API of various services that provide images. My apps work with them quite well, but only until the API developers decide to change something in their API specification. In this case, I have to modify my entire app. I decided it was a good idea to separate the specifications of each service into a separate file so that when any of the APIs are changed, the rework of my app only consists of editing this configuration file. Any set of images can be represented in the form of a certain universal structure that can be used in many projects. Let's write an example of this in JSON format: dataset =
{
  "name": "My animals",
  "desc": "My animals dataset descrtiption",
  "items": [
    {"id": 0,
    "title": "My dog image",
    "thumbnail": "https://loremflickr.com/150/150/dog",
    "src": "https://loremflickr.com/1680/1050/dog"
    },
    {"id": 1,
      "title": "My cat image",
      "thumbnail": "https://loremflickr.com/150/150/cat",
      "src": "https://loremflickr.com/1680/1050/cat"
    },
    {"id": 2,
      "title": "My parrot image",
      "thumbnail": "https://loremflickr.com/150/150/parrot",
      "src": "https://loremflickr.com/1680/1050/parrot"
    }
  ]
} There is a kind of description of the dataset, and an array containing image elements with their descriptions and links to the sources of images themselves. If necessary, it will be possible to make changes to this structure, but these changes will usually be associated with some changes in our project. When we retrieve data from an image search service using the appropriate API, the results for each service will be different. For example, when using the Flickr service, the flickr.photos.search method will return results in the following format: response =
{
    "photos": {
        "page": 1,
        "pages": 89071,
        "perpage": 25,
        "total": 2226767,
        "photo": [
            {
                "id": "12312362",
                "title": "Cat",
                "description": {
                    "_content": "My favorite cat..."
                },
                "datetaken": "2015-06-05 19:23:19",
                "ownername": "User512341234",
                "latitude": "57.142993",
                "longitude": "33.699757",
                "place_id": "uQBm12323UrxpE99h",
                "url_q": "https://live.staticflickr.com/1957/45543214321_abcabcabac_q.jpg",
                "url_l": "https://live.staticflickr.com/1957/45543214321_abcabcabac_b.jpg",
            },
			...
		]
    },
    "stat": "ok"
  }
} Here the array of image elements is in the element. response.photos.photo The image url is in . response.photos.photo [index].url_l The thumbnail URL (image preview) is in . response.photos.photo [index].url_q And the description will be contained in . response.photos.photo [index].description._content Using the Pixabay API, the image search response will be as follows: response =
{
    "total": 23858,
    "totalHits": 500,
    "hits": [
        {
            "id": 736877,
            "pageURL": "https://pixabay.com/photos/tree-cat-736877/",
            "type": "photo",
            "tags": "tree, cat, silhouette",
            "previewURL": "https://cdn.pixabay.com/photo/2015/.../tree-736877_150.jpg",
            "largeImageURL": "https://pixabay.com/get/g07531348f4443b076ebc0567_1280.jpg",
        },
		...
    ]
} The array of image elements should be taken from the element. response.hits The image url is in response.hits[index].largeImageURL The thumbnail URL is in response.hits[index].previewURL The description will have to be taken from some other elements. In the examples above, I have omitted some of the fields to make it easier to understand their structure. To process responses from different services in the same way, we need to convert them to the format of our dataset. First, let's describe the classes that represent our image element and a set of images. For the image: class Item {
  constructor(object, schema) {
    this.id = getProperty(object, schema.item_id);
    this.title = getProperty(object, schema.item_title);
    this.desc = getProperty(object, schema.item_desc);
    this.thumbnail = getProperty(object, schema.item_thumbnail);
    this.src = getProperty(object, schema.item_src);
  }
} For the dataset: class Dataset {
  constructor(object, schema) {
    this.name = "";
    this.desc = "";
    schema.ds_name.forEach(e => { this.name += getProperty(object, e); });
    schema.ds_desc.forEach(e => { this.desc += getProperty(object, e); });
    this.items = getProperty(object, schema.items).map(
      i => new Item(i, schema)
    );
  }
} The constructors of these classes create objects whose structure is similar to that of our dataset. In the dataset constructor, we also call the constructor to create the items. The getProperty function allows you to get the value of an element from any object by specifying the path to it (for example, photos.photo). You can see its code later. The key point here is that we pass 2 parameters to the constructors: and . object schema is the original formatted dataset or image element that the API service returned to us. object - an object containing the mapping of object elements to elements of our dataset. schema We can put the above code in datasets.js file as a module. Let's describe the schemas for three image services (Flickr, Pixabay, Pexels): export const FLICKR_SCHEMA = {
  ds_name: ["My Flickr dataset. Page#: ", "photos.page", ", total pages: ", "photos.total"],
  ds_desc: ["Photos per page: ", "photos.perpage"],
  items: "photos.photo",
  item_id: "id",
  item_title: "title",
  item_desc: "description._content",
  item_thumbnail: "url_q",
  item_src: "url_l"
};

export const PIXABAY_SCHEMA = {
  ds_name: ["My Pixabay dataset. Total: ", "total"],
  ds_desc: ["Total hits: ", "totalHits"],
  items: "hits",
  item_id: "id",
  item_title: "title",
  item_desc: "tags",
  item_thumbnail: "previewURL",
  item_src: "largeImageURL"
};

export const PEXELS_SCHEMA = {
  ds_name: ["My Pexels dataset. Page: ", "page"],
  ds_desc: ["Per page: ", "per_page", " Total results: ", "total_results"],
  items: "photos",
  item_id: "id",
  item_title: "photographer",
  item_desc: "url",
  item_thumbnail: "src.tiny",
  item_src: "src.original"
}; The names of the keys in the schemas correspond to the format of our dataset, and the values tell us from which elements to take for the corresponding keys. As you can see, we refer to different elements depending on the service. For ds_name and ds_desc, I used arrays, which will be concatenated into a string using forEach in the dataset constructor. Let's save our schemas in the dataschemas.js file. To test this idea, we will develop a simple web application based on the following logic: Enter search string Select an image search service Click the "Search" button Call the API of the corresponding service and get the result Call the Dataset constructor, into which we transfer the received response in JSON format, as well as the corresponding API schema The constructor returns an object of the format of our dataset Use a function to draw the resulting images into the DOM Let's sketch out the HTML structure: <!DOCTYPE html>
<html>
<head>
  <meta charset='utf-8'>
  <meta http-equiv='X-UA-Compatible' content='IE=edge'>
  <title>Image APIs Schemas</title>
  <meta name='viewport' content='width=device-width, initial-scale=1'>
  <link rel='stylesheet' type='text/css' media='screen' href='main.css'>
  <script type="module" src='main.js'></script>
</head>
<body>
  <header>
    <input id="searchText" type="text" placeholder="Input search text" value="skyline">
    <select id="sourceType">
      <option value="flickr">Flickr</option>
      <option value="pixabay">Pixabay</option>
      <option value="pexels">Pexels</option>
    </select>
    <button id="searchImages">Search Images</button></header>
  <main></main>
</body>
</html> In the HTML file, we will include our main.js script as a module. The main.css file contains the minimum style settings for the correct display of elements. Image services use personal API keys, let's put them in a separate file, api_keys.js: export const FLICKR_API_KEY = "abcdef123456789";
export const PIXABAY_API_KEY = "abcdef123456789";
export const PEXELS_API_KEY = "abcdef123456789"; Anyone can get the keys for free by registering on the corresponding service. Let's include our JS files in the main.js script and write some code to implement our logic: import { Dataset } from "./datasets.js";
import * as Schemas from "./dataschemas.js";
import * as Keys from "./api_keys.js";

let myDataset;
let flickrSearchURL = "https://api.flickr.com/services/rest/?method=flickr.photos.search&format=json&nojsoncallback=1&sort=interestingness-desc&per_page=5&page=1&extras=o_dims,url_sq,url_t,url_s,url_q,url_m,url_n,url_z,url_c,url_l,url_o,description,geo,date_upload,date_taken,owner_name&per_page=25";
let pixabaySearchURL = "https://pixabay.com/api/?image_type=photo&per_page=25";
let pexelsSearchURL = "https://api.pexels.com/v1/search?per_page=25";

window.onload = () => {

  document.querySelector("#searchImages").onclick = () => {
    let queryString = document.querySelector("#searchText").value;
    let sourceType = document.querySelector("#sourceType").value;
    let searchUrl, options, schema;

    switch ( sourceType ) {
      case 'flickr':
        searchUrl = `${flickrSearchURL}&api_key=${Keys.FLICKR_API_KEY}&text=${queryString}`;
        schema = Schemas.FLICKR_SCHEMA;
        options = {mode: "cors"};
        break;
      case 'pixabay':
        searchUrl = `${pixabaySearchURL}&key=${Keys.PIXABAY_API_KEY}&q=${queryString}`;
        schema = Schemas.PIXABAY_SCHEMA;
        options = {mode: "cors"};
        break;
      case 'pexels':
        searchUrl = `${pexelsSearchURL}&query=${queryString}`;
        schema = Schemas.PEXELS_SCHEMA;
        options = {headers: {Authorization: `${Keys.PEXELS_API_KEY}` }, mode: "cors"};
        break;
    }

    fetch(searchUrl, options)
    .then( response => response.json())
    .then( json => {
      console.log(json);
      myDataset = new Dataset(json, schema);
      myDataset.draw(document.querySelector("main"));
      console.log(myDataset);
    });
  }
  
} In the code, we have one onclick event handler on the button, which implements the algorithm described above. Depending on the selected service, we form the corresponding search URL string, call the API, and create a dataset, converted from the result using the appropriate schema. Now it's time to test our application. Let's install a web server: npm install http-server –g To start the web server, we will use the command (you can specify any other port): http-server -p 3000 This is how the page of our application looks like: Let's search on Flickr: By adding the output of the response received from the Flickr service and the resulting dataset to the developer console, we can see how the results were converted to the desired format: The same for the Pixabay service: And for the Pexels service: Thus, to add a data transformation for an additional service, you just need to add a description of the schema of this service to the dataschemas.js file and use this schema when calling the dataset constructor. If the API specification changes, simply correcting the schema description will be enough. I would like to note that this approach is applicable not only to image search services but also to any other services that are similar in type of returned results. I hope that this idea will be useful to someone developing similar applications. The source code of the project can be taken here: https://github.com/yuridanil/apimapping

Using JSON Mapping to Work with APIs of Various Image Services

Mastering the Meta-Skill of Learning

A is a sort of API that allows developers to create applications and services for cloud hardware, software, and platforms deployment. A cloud API is a portal or interface that connects users to cloud infrastructure and software applications, both directly and indirectly. A cloud API engages with a cloud infrastructure to distribute processing, storing, and system resources for web software and services that have been demanded. API integration tools can help you prevent data clutter by pulling information from relevant database systems. Cloud Application Programming Interface (Cloud API) Cloud data storage opens up a world of possibilities, and cloud integration services are expanding to meet those needs, including cloud storage providers with as-a-service capabilities that supply solutions tailored to specific hybrid API integration issues. System administrators are searching for new methods to interact with their cloud model as cloud services consolidate. Companies and developers have the largest hurdle in integrating their system infrastructure with these cloud storage providers or cloud-based services, which are frequently provided by third-party suppliers and enhancing the overall experience that results from that strategic shift. API integration is the actual deal in all of this. Data management on the cloud is one of the most significant technological breakthroughs in recent years. Not only for huge amounts of data but also for platforms or services for end-users, such as customers or employees of a corporation. Hundreds of tools and capabilities for managing information in the cloud, ranging from office automation to data storage through applications, are the outcome of this work. Any public cloud operation depends on a cloud API, which is often built on the and approaches, along with cross-platform and vendor-specific APIs. REST SOAP To simplify the API integration for cloud data storage extension and your application’s functionality improvement, we defined a step-by-step description of how to implement the most known and used Cloud APIs: , , and . Google Drive API Dropbox API OneDrive API Integration with Google Drive enables you to develop apps that use Google's cloud data storage. Using the Google Drive API, you can design apps that interact with Google Drive as a cloud storage provider that offers extensive functionality, such as: transferring your data model to the VDR once and then trace the VDR to numerous target systems, managing every element of the user interface and user experience,  and extendible CE's Elements that require less maintenance. Google Drive API Getting client keys for Google Drive API The first thing we should do for API integration is to create client keys. Navigate to the APIs & Services → Credentials page in the Cloud Console. Then select OAuth client ID in "Create credentials." If you haven’t configured the consent screen go on with configuring. Configuring the Consent Screen On the first step fill in all the required fields and optional if needed. In the second step, we should specify the scopes we want. Click “Add or remove scopes”. For using Google Drive API we need to have scope. Use the ‘Manually add scopes’ section. ‘ https://www.googleapis.com/auth/drive’ Go to the last step and save the data. Creating Client Keys Select the app type and specify the name of it. In our case, the type is a Web application. Specify the app and redirect URIs.  Usually, app URI is our client web application URI, and redirect URI is the server-side route that is going to handle Shopify requests after the OAuth process is completed. After you get your client id and secret, copy and save them to your project configuration file. OAuth To work with google API a good choice is to use the . library ‘GoogleAPIs’ Let us create a service to work with Google Drive API and in it the client with secret keys. import { google } from 'googleapis';
import { OAuth2Client } from 'google-auth-library';

const { clientId, clientSecret, redirectURL } = cfg.googleDriveAPI;

class GoogleDriveService {
  private gdriveClient: OAuth2Client;

  constructor() {
    this.gdriveClient = new google.auth.OAuth2(
      clientId,
      clientSecret,
      redirectURL,
    );

    google.options({
      auth: this.gdriveClient,
    });
  }
} To generate an OAuth URL for the web client we can create a special method, specifying access type and scope for Google Drive cloud storage provider. public getAuthUrl() {
    const authUrl = this.gdriveClient.generateAuthUrl({
      access_type: 'online',
      scope: 'https://www.googleapis.com/auth/drive',
    });

    return authUrl;
  } Our client application is going to redirect to this URL, and the Google auth form will be presented. After the user logs in successfully, the user will be redirected to the URL you specified. As we specified our back-end endpoint, let's create one. Firstly we need to add a method to our service public async getToken(code: string, redirectUri: string) {
    const { tokens } = await this.gdriveClient.getToken({ code, redirect_uri: redirectUri });

    this.gdriveClient.setCredentials(tokens);
    return tokens;
  } The endpoint should be similar to the implementation below. router.get('/googledrive-auth', async (req: Request, res: Response) => {
  const { code } = req.query;
  const token = await googleDriveService.getToken(code, cfg.googleDriveAPI.redirectURL);

  // save token to e.g. redis
  // redirect to the FE page
}); Our query params payload will include code, which can be used only once to receive an access token. A good way to save a token to some cache storage and send a redirect as the response. After you get the token you can use the endpoints of Google drive API. For example, let’s add a method to get a file by its id: public getFile(
    accessToken,
    fileId,
  ) {
    this.gdriveClient.setCredentials({ access_token: accessToken })

    return drive.files.get(
      { auth: this.gdriveClient, fileId })
  } Integration with Dropbox Developers may use the to interact with Dropbox files, including sophisticated features like full-text search, thumbnails, and sharing. Dropbox API also includes regular authentication procedures to eliminate endpoint subtlety, as well as standardized methods and calls among all APIs, webhooks, and monitoring. Dropbox API Getting Client Keys for the Dropbox API Firstly we should create an application using your Dropbox console. After you created the application we need to add the OAuth redirect URI in the app settings. Your app key and secret information are available in settings. Now when we have keys we can start creating a service to work with Dropbox API. We are using . library Dropbox SDK import { Dropbox } from 'dropbox';

export class DropboxService {
  protected dbxOauth: Dropbox

  constructor(config: Record<'clientId' | 'clientSecret', string> = cfg.dropboxAPI) {
    const { clientId, clientSecret } = config;

    this.dbxOauth = new Dropbox({ clientId });
    this.dbxOauth.setClientSecret(clientSecret);
  }
} OAuth To start the OAuth process we should form the URL which should be opened in the browser(usually by the client-side of the application). It should include the and query parameters, including client ID(from settings of the app), redirect URI (one of configured in settings), and response type(we are using code-based OAuth flow. base URL of the Dropbox OAuth page This will open . the Dropbox OAuth window After you log in and allow your app to access the data on your account you will be redirected to the URI you specified with code in the query params. Let’s create a handler for it. Firstly we need to add a method to our service to exchange codes and get access tokens. public async getToken(code: string, redirectUri: string) {
    const token = await this.dbxOauth.getAccessTokenFromCode(redirectUri, code);

    return token;
  } The endpoint should be similar to the implementation below. router.get('/dropbox-auth, async (req: Request, res: Response) => {
  const { code } = req.query;
  const token = await dropboxService.getToken(code, cfg.dropboxAPI.redirectURL);

  // save token to e.g. redis
  // redirect to the FE page
}); Using API Now when we have a token, let’s create a helper to get an authorized client for the Dropbox API. protected async getClient(accessToken: string) {
    const dbxClient = new Dropbox({ accessToken });

    return await dbxClient;
  } Now we can use the API. For example, getting current users should look like below. public async getCurrentUser(accessToken: string) {
    const dropboxClient = await this.getClient(accessToken);
    const user = await dropboxClient.usersGetCurrentAccount();

    return user;
  } Integration with One Drive With the , it is possible to work with files in a number of settings, including Microsoft Teams, Groups, SharePoint, and more. Users may view these files from anywhere, exchange links to files, and copy or transfer data to team drives using OneDrive. Customers can trust the sophisticated encryption, compliance, and security capabilities in OneDrive API to keep their data safe. OneDrive API Getting Client Keys for the OneDrive API Create an application within your . We are using to redirect URI. Microsoft Azure platform SPA type After you create your client ID, it is available on the overview page. After that, we have to create the client secret on the Certificates & Secrets page After you have created it you can save the value of it to configuration files. Now we should update our API permissions. Go to the OneDrive API permissions tab and add (for accessing Onedrive files) and (for authorization). Files.ReadWrite User.Read OAuth The OAuth URI should contain clientID, scopes, and response type, which in our case represents . this URL After you log in to the OneDrive API, cloud data storage and allow your app to access the data on your account you will be redirected to the URI you specified with code in the query params. Let’s create a service and auth handler for it. We are using : simple-oauth2 library import * as simpleOauth2 from 'simple-oauth2';

const { clientId, clientSecret } = cfg.oneDriveAPI;

class OneDriveService {
  private oneDriveOauth = simpleOauth2.create({
    client: {
      id: clientId,
      secret: clientSecret,
    },
    auth: {
      tokenHost: 'https://login.microsoftonline.com/common',
      authorizePath: '/oauth2/v2.0/authorize',
      tokenPath: '/oauth2/v2.0/token',
    },
  })

  public async getToken(code: string, redirectUri: string) {
    const rawTokenData = await this.oneDriveOauth.authorizationCode.getToken({
      code,
      redirect_uri: redirectUri,
    });

    return this.oneDriveOauth.accessToken.create(rawTokenData);
  }
} The endpoint should be similar to the implementation below. router.get('/onedrive, async (req: Request, res: Response) => {
  const { code } = req.query;
  const token = await onedriveService.getToken(code, cfg.oneDriveAPI.redirectURL);

  // save token to e.g. redis
  // redirect to the FE page
}); Using the API Now when we have a token, let’s create a helper to get an authorized client for the API integration. private getClient(token: string) {
    return MicrosoftGraph.Client.init({
      authProvider: (done) => {
        done(null, token); //first parameter takes an error if you can't get an access token
      }
    });
  } Now we can use the OneDrive API. For example, getting current users should look like below. public async getCurrentUser(accessToken: string) {
    const client = this.getClient(accessToken);

    return client.api('/me')
      .select(['id', 'displayName', 'userPrincipalName'])
      .get();
  } Last comments Cloud API is a set of automation tools that assist link software applications and API integration tools independent of their deployment environment. Furthermore, API integration of cloud data storage provides a single dashboard for managing, governing, and integrating cloud-based applications, utilizing tools that link cloud applications and services and regulate integration flow. The integration of cloud storage providers breaks down the process, improves visibility, and simplifies corporate operations by bringing diverse information solutions together. It's critical to thoroughly comprehend what cloud data storage does and can accomplish before learning how to take advantage of the potential it offers. Since there are a variety of Cloud API Integration tools available, you should ensure that the one you implement - fulfills all of your demanded functionalities. Also posted on: https://incorainc.com/cloud-api-use-cases-for-google-drive-dropbox-onedrive-api/

Stories, News & Mentions about WETRANSFER

Wetransfer’s Stories on HackerNoon

Wetransfer's News & Mentions