Madrid is a city of rooftops. Cast your gaze upwards – there are a multitude of terraces that overlook neighbourhoods throughout town. Many belong to hotels and restaurants while others are part of apartment blocks. Invited to review Ocean Drive Madrid ...

Hotel Ocean Drive – Madrid

Girls Gone Hallmark - a Hallmark movie review podcast - dish on the holiday flick from Hallmark Movies and Mysteries "Ms. Christmas Comes to Town."

Ms. Christmas Comes to Town

The grill experience was certainly an impressive spectacle, and KGK provided an excellent version of the classic Korean barbecue with high-quality ingredients, helpful staff to provide assistance and information on the menu, and luxurious surroundings.

Korean Grill Kensington – Barbecue Korean Style

Split sharing plates, tacos, and small snacks at El Ta'koy, an intimate Covent Garden restaurant with its spirit of Aloha.

El Ta’koy, Hawaiian Restaurant in Covent Garden

Welcome to Girls Gone Hallmark, a podcast dedicated to reviewing Hallmark movies! Today, Megan and Wendy will be sharing their thoughts on the highly talked about movie “Where Are You, Christmas?” which premiered during the first weekend of Hallmark ...

Where Are You, Christmas?

The perfect getaway! We experience the exquisite views of Barcelona from the luxurious Penthouse Suite of Hotel Arts Barcelona.

Hotel Arts Barcelona

The Limit is a new piece based on the play Lemons lemons lemons lemons lemons by Sam Steiner, seen at the Harold Pinter back in February 2023 (read our review here). A hush-law is introduced that reduces the number of words a person can speak in a day to ...

The Limit – Linbury Theatre

Zeldin wants us each to feel The Confessions is about our lives - for me that was my relationship with my mother and my own life experiences

The Confessions – Lyttelton Theatre at the National

Moonlit musings on impossible love viewed through the lens of virtuosic strings players and an award-winning dancer

Mullova Ensemble: Transfigured Night Review

Disney+ has been the go-to streaming service for all things Disney since its launch in 2019. The service offers a wide range of films, TV shows, and documentaries from brands such as Marvel, Star Wars,

Disney+ November Lineup – Holiday Shows and Family Favorites!

BLOGLOVIN

bloglovin

Looks like it’s blockchain split season . For background of various people discussing the topic, and whether such splits are good or bad: again Power laws and network effects (arguing the BTC/BCC split may destroy value due to network effect loss): Brian Armstrong on the Ethereum Hard Fork (last year): Phil Daian on the ETH/ETC split: https://medium.com/crypto-fundamental/power-laws-and-network-effects-why-bitcoincash-is-not-a-free-lunch-5adb579972aa https://blog.coinbase.com/on-the-ethereum-hard-fork-780f1577e986 http://pdaian.com/blog/stop-worrying-love-etc/ Given that ecosystem splits are not going away, and we may well see more of them in the crypto industry over the next decade, it seems useful to inform the discussion with some simple economic modeling. With that in mind, let’s get right to it. Suppose that there exist two projects A and B, and a set of users of total size N, where A has N_ausers and B has N_b users. Both projects benefit from network effects, so they have a utility that increases with the number of users. However, users also have their own differing taste preferences, and this may lead them to choose the smaller platform over the bigger platform if it suits them better. We can model each individual’s private utility in one of four ways: p and q are private per-user parameters that you can think of as corresponding to users’ distinct preferences. The difference between the first two approaches and the last two reflects differences between interpretations of Metcalfe’s law, or more broadly the idea that the per-user value of a system grows with the number of users. The suggested a per-user value of N (that is, a total network value of N2), but other analysis (see ) suggests that above very small scales N*log(N) usually dominates; there is a controversy over which model is correct. The difference between the first and second (and between the third and fourth) is the extent to which utility from a system’s intrinsic quality and utility from network effects are complementary - that is, are the two things good in completely separate ways that do not interact with each other, like social media and coconuts, or are network effects an important part of letting the intrinsic quality of a system shine? original formulation here We can now analyze each case in turn by looking at a situation where N_a users choose A and N_busers choose B, and analyze each individual’s decision to choose one or the other from the perspective of economic externalities - that is, does a user’s choice to switch from A to B have a positive net effect on others’ utility or a negative one? If switching has a positive externality, then it is virtuous and should be socially nudged or encouraged, and if it has a negative externality then it should be discouraged. We model an “ecosystem split” as a game where to start off N_a = N and N_b = 0 and users are deciding for themselves whether or not to join the split, that is, to move from A to B, possibly causing N_a to fall and N_b to rise. Switching (or not switching) from A to B has externalties because A and B both have network effects; switching from A to B has the negative externality of reducing A’s network effect, and so hurting all remaining A users, but it also has the positive externality of increasing B’s network effect, and so benefiting all B users. Case 1 Switching from A to B gives N_a users a negative externality of one, so a total loss of N_a, and it gives N_b users a positive externality of one, so a total gain of N_b. Hence, the total externality is of size N_b - N_a; that is, switching from the smaller to the larger platform has positive externalities, and switching from the larger platform to the smaller platform has negative externalities. Case 2 Suppose P_a is the sum of p values of N_a users, and Q_b is the sum of q values of N_busers. The total negative externality is P_a and the total positive externality is Q_b. Hence, switching from the smaller platform to the larger has positive social externalities if the two platforms have equal intrinsic quality to their users (ie. users of A intrinsically enjoy A as much as users of B intrinsically enjoy B, so p and q values are evenly distributed), but if it is the case that A is bigger but B is better, then there are positive externalities in switching to B. Furthermore, notice that if a user is making a switch from a larger A to a smaller B, then this itself is revealed-preference evidence that, for that user, and for all existing users of B, q/p > N_a / N_b. However, if the split stays as a split, and does not proceed to become a full-scale migration, then that means that users of A hold different views, though this could be for two reasons: (i) they intrinsically dislike A but not by enough to justify the switch, (ii) they intrinsically like A more than B. This could arise because (a) A users have a higher opinion of A than B users, or (b) A users have a lower opinion of B than B users. In general, we see that moving from a system that makes its average user less happy to a system that makes its average user more happy has positive externalities, and in other situations it’s difficult to say. Case 3 The derivative of ln(x) is 1/x. Hence, switching from A to B gives N_a users a negative externality of 1/N_a, and it gives N_b users a positive externality of 1/N_b. Hence, the negative and positive externalities are both of total size one, and thus cancel out. Hence, switching from one platform to the other imposes no social externalities, and it is socially optimal if all users switch from A to B if and only if they think that it is a good idea for them personally to do so. Case 4 Let P_a and Q_b are before. The negative externality is of total size P_a/N_a and the positive externality is of total size Q_b/N_b. Hence, if the two systems have equal intrinsic quality, the externality is of size zero, but if one system has higher intrinsic quality, then it is virtuous to switch to it. Note that as in case 2, if users switching from a larger system to a smaller system, then that means that they find the smaller system to have higher intrinsic quality, although, also as in case 2, if the split remains a split and does not become a full-scale migration, then that means other users see the intrinsic quality of the larger system as higher, or at least not lower by enough to be worth the network effects. are The existence of users switching to B suggests that for them, q/p >= log(N_a)/log(N_b), so for the Q_B/N_b > P_a/N_a condition to not hold (ie. for a move from a larger system to a smaller system not to have positive externalities) it would need to be the case that users of A have similarly high values of p - an approximate heuristic is, the users of A would need to love A so much that if were the ones in the minority that would be willing to split off and move to (or stay with) the smaller system. In general, it thus seems that moves from larger systems to smaller systems that actually do happen will have positive externalities, but it is far from ironclad that this is the case. they Hence, if the first model is true, then to maximize social welfare we should be trying to nudge people to switch to (or stay with) larger systems over smaller systems, and splits should be discouraged. If the fourth model is true, then we should be at least slightly trying to nudge people to switch to smaller systems over larger systems, and splits should be slightly encouraged. If the third model is true, then people will choose the socially optimal thing all by themselves, and if the second model is true, it’s a toss-up. It is my personal view that the truth lies somewhere between the third and fourth models, and the first and second greatly overstate network effects above small scales. The first and second model (the N2form of Metcalfe’s law) essentially state that a system growing from 990 million to 1 billion users gives the same increase in per-user utility as growing from 100,000 to 10.1 million users, which seems very unrealistic, whereas the N*log(N) model (growing from 100 million to 1 billion users gives the same increase in per-user utility as growing from 100,000 to 10 million users) intuitively seems much more correct. And the third model says: if you see people splitting off from a larger system to create a smaller system because they want something that more closely matches their personal values, then the fact that these people have already shown that they value this switch enough to give up the comforts of the original system’s network effects is by itself enough evidence to show that the split is socially beneficial. Hence, unless I can be convinced that the first model is true, or that the second model is true and the specific distributions of p and q values make splits make negative negative externalities, I maintain my existing view that those splits that actually do happen (though likely not splits that end up not happening due to lack of interest) are in the long term socially beneficial, value-generating events. hypothetical All content written by me is by default released freely under the . WTFPL

A Note on Metcalfe's Law, Externalities and Ecosystem Splits

Coinbase Earn program recently launched Earn on Coinbase in which the users have to watch educational videos to learn about new coins and tokens, then earn them by answering skill-testing quizzes! Looks easy, let us know how to get started and how to make max out of it. First Register your account with Coinbase So, register yourself on Coinbase . Fill the details, verify your accounts by filling KYC(Know Your Customer) form. Now, next thing what you need to do is register on Earn.com . Again fill the details and verify your KYC. Once you are registered with both of them you are good to go. Now sign in to your Coinbase account scroll down you will see something like the above gif. Or just change URL to coinbase.com/earn. Once you visit the link you will see all available video tutorials and corresponding earnings like below: From my system How Just start the course, every time you watch a video from the course you have to answer some questions which are related to that video. Once done you will receive some amount in that specific crypto in your account. As easy as that. Currently, only US Coinbase customers can start this course, while all others don’t need to worry! they can still view all content on the page for free, and they may join the waitlist to be notified once earning opportunities become available to their country. According to this article https://blog.coinbase.com/earn-50-of-xlm-for-learning-about-stellar-and-inviting-your-friends-2183effcde16 Up to one billion XLM will be distributed in the Earn XLM opportunity, 100% of which will go towards our customers. These funds are being provided by the Stellar Development Foundation (SDF), a nonprofit organization that helps develop the Stellar protocol. How to get max out of it For now, if you are a US respondent, just go register on Coinbase and Earn and you can start right away with these courses and earn. While if you are from another country go register and join the waitlist. Once it is available in your country you will get notified over the mail and you can start right away. Conclusion Coinbase Earn program is available from a while now. But coinbase never did this directly through their own platform instead they did using Earn.com. But now, if they are doing this they must have a some vision for future. That’s something we have to look forward for. Support my article by registering through my referral links here - Coinbase — https://www.coinbase.com/join/5a002782a6ecfb00eafeca8f Earn — https://earn.com/denydani/referral/?a=8qicl4n22nlashuf

What is Coinbase Earn Program, How to make max out of it

SearchPedia: A List of 250+ Search Engines

SearchPedia: una lista de más de 250 motores de búsqueda

Node is one of the most popular languages for microservices. With the rise of , increasingly, Node developers are being asked to deploy their services to a Kubernetes cluster. But what’s required to safely deploy and run Node services on Kubernetes? In this post, we focus on one specific, but vital, component: how do I understand what’s happening with my Node service on Kubernetes, and how do I debug it when things go wrong? Kubernetes At this point, you may be thinking, can’t I just use the Kubernetes dashboard? Unfortunately, while Kubernetes can automatically keep your service up in the event of node failure or a software crash, it doesn’t actually know whether your service is behaving In fact, a service may be returning 500’s or taking too long to respond and the Kubernetes dashboard will show all green lights. correctly. This is why Kubernetes is often used in conjunction with something like Linkerd. Linkerd is a that augments any Kubernetes service, providing zero-config “golden metrics” dashboards and UNIX-style CLI for runtime debugging, diagnostics, and reliability. (Linkerd can also act as a by running on multiple services, providing a uniform layer of telemetry, security, and control across them.) service sidecar tools service mesh Linkerd works by inserting an ultralight proxy (<10mb) into each pod of a service, and automatically sending traffic to and from that pod through its proxy. These proxies provide telemetry data to, and receive signals from, a control plane. Because the proxy runs alongside your application and is transparent, there are zero code changes required. And, of course, Linkerd is completely open source, Apache v2 licensed, and is hosted by the Cloud Native Computing Foundation–just like Kubernetes itself. In this tutorial, we’ll walk you through deploying Linkerd 2.0 to a Kubernetes cluster and using it to debug failures in an example application. (If you don’t have a Kubernetes cluster, don’t worry! Take a look at , or just check out the for this blog post that you can run straight from your browser.) minikube interactive tutorial The demo application we’ll deploy is composed of multiple services that allow voting for favorite gifs. These services communicate via gRPC and have all been written in Javascript. You can check out the source on . GitHub The application is composed of the following 4 services: : Web frontend and REST API nodevoto-web : gRPC API for finding and listing gif nodevoto-gif : gRPC API for voting and leaderboard nodevoto-voting : a traffic generator vote-bot This application has a major bug in it, which we’ll debug by using Linkerd’s web dashboard and UNIX-like CLI tools. Step 1: Install the demo app 🚀 Before we install Linkerd, let’s install the Nodevoto demo app. In your laptop’s terminal window, run: This command downloads the Kubernetes manifest for Nodevoto, and uses to apply it to your Kubernetes cluster. Nodevoto is comprised of several services that run in the namespace. You can see the services by running: kubectl nodevoto You can also see the app live by running: (If you see something like , you don’t have Kubernetes set up properly.) kubectl: command not found Click around the app a bit. You should see that some parts of the application are broken! (hint — click the upper left vote button a few times and see what happens). If you look at the Kubernetes dashboard, of course, you’ll see that everything appears green — all pods are running. This is a very common type of failure scenario: Kubernetes thinks everything’s fine, but you know the application is returning errors, because you can see them. In the next few steps, we’ll walk you through how to use Linkerd to diagnose the problem. Step 2: Install Linkerd’s CLI We’ll start by installing Linkerd’s command-line interface (CLI) onto your local machine. Visit the , or simply run: Linkerd releases page Once installed, add the command to your path with: linkerd Let’s validate that your cluster is prepared for Linkerd by running: As there are many different types of Kubernetes clusters, and an infinite set of ways to configure them. This handy command will report any problems that would interfere with your ability to install Linkerd. Hopefully everything looks OK and you’re ready to move on to the next step. Note: if your Kubernetes cluster is on GKE with RBAC enabled, you’ll need an extra step: you must grant a of to your Google Cloud account first, in order to install the control plane. To do that, run: ClusterRole cluster-admin kubectl create clusterrolebinding cluster-admin-binding-$USER \--clusterrole cluster-admin \--user=$(gcloud config get-value account) Step 3: Install Linkerd’s control plane onto the cluster In this step, we’ll install Linkerd’s lightweight control plane into its own namespace ( ) on your cluster. To do this, run: linkerd This command generates a Kubernetes manifest and uses to apply it to your Kubernetes cluster. (Feel free to read the full manifest before you apply it.) kubectl Depending on the speed of your connection, it might take a minute for your Kubernetes cluster to pull down the Linkerd container images and get them started. While that’s happening, you can validate that everything’s installing correctly by running: This command will wait until Linkerd has been installed and is running. Now, let’s check out Linkerd’s dashboard! Just run: If you see something similar to the screenshot below, Linkerd is now running on your cluster. 🎉 Step 4: Add Linkerd to the Nodevoto web service At this point we have the control plane installed in the namespace, and we have our nodevoto demo app installed in the namespace. But we haven’t actually added Linkerd to our service yet. So let’s do that. linkerd nodevoto In this example, let’s pretend we are the owners of the service. Let’s just say that other services, like and , are owned by other teams — we don’t want to touch them. While these are local services in this example, it is entirely possible that they could be remote APIs owned by a completely separate entity. web gif voting There are a couple ways to add Linkerd to our service. For demo purposes, the easiest is to do something like this: This command retrieves the manifest of the service from Kubernetes, runs this manifest through , and then reapplies it to the Kubernetes cluster. The command adds to the manifest to include the data plane’s proxies. As with , is a pure text operation. This means that you can inspect the input and output before you use it. Since is a Deployment, Kubernetes is kind enough to slowly roll the service one pod at a time–meaning that can be serving traffic live while we add Linkerd to it! web linkerd inject linkerd inject install inject web web We now have a service sidecar running on the service! web Step 5: Debugging for Fun and for Profit Congratulations! You now have a full gRPC application running on your Kubernetes cluster with Linkerd installed on the service. Unfortunately, that application is failing when you use it–so now let’s use Linkerd to track down those errors. web If you glance at the Linkerd dashboard (by running ), you should see all services in the namespace show up. Since has the Linkerd service sidecar installed on it, you’ll also see success rate, requests per second, and latency percentiles show up. linkerd dashboard nodevoto web That’s cool, but notice is that success rate is well below 100%! Click on and let’s debug. web You should now be looking at the Deployment page for the web service. The first thing you’ll see here is that web is taking traffic from (a service included in the Nodevoto manifest to continually generate a low level of live traffic), and has two outgoing dependencies, and . vote-bot gif voting The gif service is operating at 100%, but the voting service is failing! A failure in a dependent service may be exactly what’s causing the errors that web is returning. Let’s scroll a little further down the page, we’ll see a live list of all traffic endpoints that is receiving. This is interesting: web There are two calls that are not at 100%: the first is vote-bot’s request to the endpoint. The second is a request to from to . Very interesting! Since is an incoming request, and is an outgoing request, this is a good clue that that response from is what’s causing the problem! /api/vote VoteCartoonHalloweenGhost web voting /api/vote VoteCartoonHalloweenGhost voting Finally, if we click on the 🔬 icon for that row in the far right column, we’ll be taken to live list of requests that match this endpoint. This allows us to confirm that the requests are failing (they all have , indicating an error). gRPC status code 2 At this point we have the ammunition we need to talk to the owners of the service. We’ve identified an endpoint on their service that consistently returns an error, and have found no other obvious sources of failures in the system. voting Want more? In this tutorial, we’ve shown you how to install Linkerd on a cluster, add it as a service sidecar to just one service–while the service is receiving live traffic! — and use it to debug a runtime issue. But this is just the tip of the iceberg. For example, everything we did above using the web UI can also be accomplished via pure CLI commands, e.g. , , and . linkerd top linkerd stat linkerd tap Also, did you notice the little Grafana icon on the very first page we looked at? Linkerd ships with automatic Grafana dashboards for all those metrics, allowing you to view everything you’re seeing in the Linkerd dashboard in a time series format. Check it out! Linkerd has a thriving community of adopters and contributors, and we’d love for YOU to be a part of it. For more, check out the and repo, join the and mailing lists ( , , ), and, of course, follow on Twitter! We can’t wait to have you aboard! docs GitHub Linkerd Slack users developers announce @linkerd Originally published at blog.linkerd.io on November 13, 2018.

Debugging Node Services in Kubernetes With Linkerd 2.0

The rates of bitcoin increased in 2017 and reached the highest level of 1700% in a single year. It was the perfect year for everyone who invested in digital currency before 2017. It was the signs that people can generate a reasonable amount of profit by investing in bitcoin and . However, the people who missed the opportunity or invested in the bitcoin late still do not know that whether they would be able to generate any profit from it or not. blockchain technology There is a complicated global computer system that is used to manage all the applications that are used to run blockchain technology. That is why most people find it different to understand due to which they are unable to integrate blockchain with aspects like a business, money making, and global money transfer. There are many people who are interested in investing in security tokens, but they do not know whether it would be the right decision for them or not. If you are serious about investing in tokens, here are a few important things you need to consider. What is a Security Token? The complete definition of a is quite complex. Indeed, in the stock exchange system, are what is known in French as securities. That is, just about any stock that can be bought or the sold on the stock market, whether it’s a company share, a debt, or some derivative. security token securities In the world of crypto-assets, a lot of people make the mistake of linking names to the tokens without any connection to their characteristics, often simply by misunderstanding the definitions recognized by the stock market. In this case, there are many tokens classified today as by various blogs and journalists. That is to say, if we believe this name, as well as the definition of a security, these , represent either a title of ownership (a part of society) or a title of debt (a debt to society). security tokens “token-values” How Does a Token Gain Value? As William Mougayar points out in , there are three tenets to token value and they are: his Medium article Role. The Features. Purpose. These three are locked up in a triangle and they look like this: Every Token role contains its own purpose and set of features which can be described best in the following table: But it is neither the first nor the second case: confer no share of society on their holders, and they represent no debt to the creator of the crypto-asset. security tokens The terms used by the vast majority of journalists and bloggers are therefore technically completely false. However, it is not entirely without reason that this name appeared: indeed, it is notably following the decisions and comments of the , an American entity responsible for the regulation of the Stock Exchange in the United States, that various chips have been compared to conventional . SEC (Securities and Exchange Commission) securities So let’s say these tokens are if you want to use the original term. We must still establish a well-defined list of their characteristics so as not to be mistaken about what we buy. value-tokens In this case, these are tokens: Whose by the person or persons who issued them; value depends on the work done , nor any , Offering no guarantee of achievement of the desired objectives guarantee of value . Having very often no use as long as the objectives are not reached Conferring on the holder no rights in the decisions of the issuing entity. These token securities have no characteristics in common with corporate units or debt securities. It would certainly be more correct to call them or since this is usually their only function: to put money on an asset hoping that its value will increase later. investment tokens investor tokens However, it remains true that some countries like the United States seem to want to apply to these tokens the same laws that they apply to traditional securities. The name of is therefore not completely meaningless. It’s just a matter of being when a chip purports to match the characteristics of traditional securities: you should not think that holding KuCoinShares gives you the right to take part in KuCoin meetings, for example. token-value extremely vigilant 1- Consider token as a code Tokens that are issued using the Ethereum platforms are similar to a piece of code that leads to the formation of the smart contract. In the code, there is a complete list of people with their wallet address as well as the balance of their tokens. During the transfer of tokens, the balance in the tokens will be changed. In the smart contract storage, all transactions will be recorded. You have to assure that the token code and platform you are selecting is reliable and authentic. The functionality should be easy to use and understand. Check the interface of the token because it will give you the perfect idea that whether you will be able to use the services or not. Make sure that you do not invest in security tokens which you cannot understand because it will create issues for you in the long run and you will not be able to get the services that you invested in. 2- Type of token One of the most important things you have to consider is the type of token you will get. According to the , in the business field, you can gain two types of profit by investing in tokens. With the security tokens, you can get the assurance that you will generate a profit in the future. Make sure that the type of security token you will select is profitable and the team will surely distribute all the profit that it has generated. Security Token Conferences You have to pay attention to the type of services a token is providing. After that, you have to conduct your own research to find out that whether such services will be beneficial in the coming future or there are other technologies available. It will give you a perfect idea regarding the type of security tokens you should invest in. 3- Total Token supply cap Make sure that you check the supply cap of the tokens which you have selected. You should know that there are some developers who will not share the supply cap of the tokens. In this situation, you will take a huge risk by investing in such type of tokens because things can get confusing for you if you do not generate any profit. If you cannot find the supply cap of tokens, it is better than you consult the token developers because that is the only way you can get the idea of the profit you can generate. To understand Token Sales Structure read this article: _Spoiler alert: it doesn’t exist_blog.coinbase.com The perfect token sale structure There are some developers who would not share the information related to the supply cap which show that they are not reliable. This is the reason you should not invest in such types of tokens. Always invest after getting complete information because it is a major investment you are making and you cannot lose a decent amount of money. 4- Listing in exchange Most people do not invest in tokens because they want long-term profit. You should know that the participation of ICO is commonly based on speculations and they have the goal to sell their token as soon as possible at a rate 3 times higher. That is why considering the listing exchange will give you the idea about the rates and popularity of the token. Investing in the token with higher rates will increase . your chances of generating more profit As well as you have to check the previous reviews and ratings of people who have already invested in the particular token. It will give you the idea of whether the demand for the token is increasing or not. If the demand of the token you have selected in rapidly increasing, you can buy it immediately because as long as the demand is increasing the profit you can generate will be increased as well. 5- Value of token Do not forget to consider the value of the token. You should not just trust the future promises that token developers are making. Assure that the token already has some value in the market and after that, you should invest in it. You can consult different investors to get a clear idea about the value of tokens which you are planning to invest in. It is not only the present value you have to consider. You have to assure that the security token you have selected will be profitable in future as well. Select some of the top tokens for investment. It will increase your chances of generating more profit. In case you are confused and it is getting hard for you to select the best type of tokens the best solution is getting some advice from the experts. They will let you know that which type of tokens are the best for you to assure that you can get the profit that you need in the long run. Make sure that you wisely select your tokens for better results.

Top 5 Things to Look Out for Before Investing in a Security Token

Best practice from Alibaba’s caching technology team on how to best deploy non-volatile memory(NVM) to production environments Effective data storage is essential in any computing task, but when you run a multi-sector ecosystem of e-commerce platforms serving billions of consumers, there is simply no substitute for it. For Alibaba who runs the world’s largest online marketplaces, that meant developing its own package of non-volatile memory (NVM) caching services collectively known as Tair MDB, first launched to support the Tmall 6.18 online shopping festival before undergoing optimization for broader rollout. To diagnose necessary improvements, the Tair team subjected the system to two full-link pressure tests, exposing a range of problems including imbalanced writing and lock overhead. Today we look more closely at the fundamentals of NVM as found in Alibaba’s production environment, with emphasis on best practices uncovered during their optimization work. As well as three strategic design rules which can help ensure long-term operability, readers working in related areas will find abundant insights on NVM optimization widely applicable to other products. The Case for NVM At the time of NVM’s adoption, Tair MDB was already widely deployed within the Alibaba Group. With the introduction of its user space network protocol stack and lock-free data structure, the QPS limit of a single unit had pushed beyond the 1000-watt caliber. All Tair MDB data was stored in memory, with the elevated single-unit QPS limit making memory capacity the most important factor determining cluster size. NVM offered a much higher single DIMM capacity while also being far less expensive than DRAM, indicating a possible approach to breaking the limit for single-unit memory capacity. NVM Enters the Production Environment: Initial Results End-to-end, with an average reading and writing latency level using DRAM’s node data under the same software version, services proved able to run as normal using NVM, and pressure for the production environment was well below the Tair MDB node limit. In subsequent sections, problems encountered during the pressure test and the approaches taken to solve them will be explained in greater detail. As previously mentioned, the maximum DIMM capacity of a single NVM is higher than that of DIMM, translating into lower cost for the same DIMM capacity than with DRAM. Using NVM to make up for insufficient memory capacity, it was possible to greatly reduce the size of the Tair MDB-capacity cluster. When factoring in device costs, electricity fees, and racks, overall costs were reducible by 30 to 50 percent. Principles in Action: A Guide to Implementing NVM Tair MDB uses NVM as a block device while using PMem-Aware File System mounting (DAX mounting). When allocating NVM space, the first step is to create and open the file in the corresponding file system path, and use posix_fallocate to allocate space. First considerations: The memory allocator NVM is intrinsically non-volatile. The caching service Tair MDB recognizes NVM as a volatile device, without need to consider the atomicity and post-crash recovery, or to explicitly call commands like clflush/clwb to forcefully flush CPU Cache contents back to medium. When using DRAM space, memory allocators such as tcmalloc/jemalloc are optional. NVM space exposes a file (or a character device) to the upper layer, so the first consideration is how to use the memory allocator. The open source program pmem[1] protects the volatile memory management library libmemkind, and easy-to-use APIs that are similar to malloc/free. This mode offers a good option when switching in most apps. Implementation of Tair MDB did not use libmemkind[2]. To explain this choice, the Tair MDB memory layout is introduced in the following section. Memory layout Tair MDB employs the slab mechanism for memory management, which does not allocate anonymous memory dynamically when in use, but rather allocates a large memory when the system starts. Subsequently, built-in memory management modules continuously distribute metadata and data pages across this large memory block, as shown in the diagram below: Tair MDB’s memory use is divided into the following portions: · Cache Meta: This stores metadata information such as the maximum number of shards, and index information for the Slab Manager. · Slab Manager: Each Slab Manager manages a Slab of a fixed size. · Hashmap: The index of global hash tables, which uses linear conflict chains to handle hash conflicts, and where all accesses to keys are processed by Hashmap. · Page pool: On starting, the page pool divides the memory into pages, each with a size of 1M. The Slab Manager requests pages from the page pool and formats them into slabs of a specified size. On starting, Tair MDB initializes all available memory. Thus, subsequent data storage sections no longer require dynamic allocation of memory from the operating system. When using NVM, it is necessary to mmap corresponding files to the memory to obtain virtual address space. The built-in memory management modules can then use this space in a transparent way. In this process, therefore, there is no need to call malloc/free again so as to manage space on NVM. Pressure Tests Begin: Issues Exposed After the deployment of NVM, 100 bytes of entries were used to perform a pressure test on Tair MDB, yielding the following data: Engine viewed latency: Client viewed QPS: As these charts indicate, NVM-based read QPS latency is roughly equivalent to that of DRAM, while its write TPS latency is approximately one third of DRAM’s. Analysis The perf result indicates that all writing performance loss takes place on the lock. The critical section that this lock manages includes page writing operations mentioned in the previously specified memory layout. The likely cause, in this case, is the higher writing latency on NVM as compared with DRAM. During pressure tests, pcm[3] was used to view the bandwidth statistics of NVM DIMMS, revealing highly imbalanced writing on one DIMM. In stable state, writing on this DIMM exceeded writing on other DIMMs by a factor of two. Details of the above are illustrated in the following figure: Before exploring these details further, the following section will offer an overview of the DIMM placement strategy used for NVM. DIMM placement strategy A single socket is arranged with four pieces of NVM DIMM in the following distribution: This placement strategy is called 2–2–1. Every socket comes with 4 pieces of DIMM belonging to four different channels, respectively. When using multiple channels, the CPU interleaves in order to use memory bandwidth more effectively. In the current placement strategy and configuration, the CPU has a unit of 4K, and interleaves in the DIMM sequence. Diagnosing hotspots: Causes of imbalance From the memory interleaving strategy, it can be deduced that all writing is done in a single zone located on the imbalanced DIMM, causing this DIMM to retain significantly more writing than other DIMMs. The next task in this case was identifying the processing logic that had led to the writing hotspot. A simplistic approach is locating suspected points and ruling them out one by one. The following section describes the approach the Tair team took to determine the processing logic. Optimization begins: Locating hotspots As mentioned above, writing hotspots result in imbalanced NVM DIMM access. Therefore, the first step in optimization is to find and process writing hotspots, such as by scattering hotspot accesses or placing access hotspots into DRAM. The Tair team used Pin to look for hotspots [4]. The aforementioned Tair MDB obtains logic addresses to operate memory by performing mmap on files. Therefore, Pin can be used to grab mmap’s return value and further obtain NVM’s logic address in the program memory space. The team then continued using Pin to stub the programmed instructions of all operation memories and count the number of writings for every byte mapped from NVM to the address space. Finally, the existence of writing hotspots was confirmed, and their corresponding zones were established as the page’s metadata. The team considered several options for tackling the writing hotspot problem, including adding padding and interleaving hotspots to each DIMM, storing fundamentally similar hot data in groups by DIMM, and moving hotspots back to DRAM. The team’s ultimate decision was to move slab_manager and page_info back to DRAM. The revised structure is as follows: Upon making these changes the imbalance issue was effectively solved, increasing TPS from 85w to 140w while decreasing in-engine writing latency from 40us to 12us. Solving excessive lock overhead When TPS is at 140w, the overhead of the aforementioned pthread_spin_lock remains very high. The perf record result indicates that pthread_spin_lock consumes this call stack: Analysis of the batch_alloc_item reveals that initializing items in the page can write huge volumes into NVM. This is where massive amounts of time are lost, as writing into NVM is slower than writing into DRAM. According to Tair MDB’s logic, locking is only needed when linking the page into the slab_manager. Thus, the initialization operations on the item can be moved out of the critical section. Following this discovery, all writing operations into NVM in the Tair MDB code were then screened and optimized accordingly. After optimization, the overhead of pthread_spin_lock dropped to normal range and TPS increased to 170w, while in-engine latency was 9us. Optimization results Balanced writing and lock granularity refinement, among other optimization efforts, effectively reduced latency and increased TPS to 170w, a 100% growth over the previous data. The difference in medium still retained a 30% deficit over the writing performance of DRAM. However, as caching service features more reading than writing, this deficit does not significantly affect the overall performance. Channeling Findings: A New Design Guide Based on their optimization efforts and production environment trials, the Tair team was able to determine a set of three key design rules for implementing NVM-based caching services. These rules are closely linked with specific NVM hardware features which significantly impact construction for caching services. Specifically, NVM is denser, less expensive, and features higher latency and smaller bandwidth than DRAM. It also presents imbalanced reading and writing issues and a higher writing latency than reading latency, and is prone to rapid wear when writing is done repeatedly at the same position. The first rule: Avoid writing hotspots Tair MDB experienced writing hotspot problems following the implementation of NVM, where writing hotspots aggravated medium wear and led to imbalanced load conditions. Before optimization, writing pressure fell squarely on just one DIMM, reflecting a failure to make full use of the entire DIMM bandwidth. In addition to memory layout (featuring mixed storage of metadata and data), access from transactions can also result in writing hotspots. The Tair team’s methods for avoiding writing hotspots include the following: · Separate metadata and data by moving the former into DRAM. Metadata is more frequently accessed than data. One example of metadata is the aforementioned page_info for Tair MDB. This makes NVM’s higher writing latency (compared with DRAM’s) less of a disadvantage from upper layers. · Apply the logic for implementing Copy-On-Write in upper layers. In some scenarios, this can reduce wear to the hardware of specified zones. Updates to a data entry in Tair MDB do not in-place update the previous entry, but add a new entry to the head of the hashmap conflict chain. Such previous entries will be deleted asynchronously. · Regularly check writing hotspots and dynamically migrate to DRAM for merges. For writing hotspots caused by accessing the aforementioned transactions, Tair MDB regularly checks and merges writing hotspots to limit access to medium in low layers. The second rule: Reduce access to the critical section NVM has higher writing latency than DRAM. Therefore, when the critical section includes operations on NVM, the concurrency degree of upper layers decreases as a result of amplified influence from the critical section. The previously mentioned issue with lock overhead did not appear when running Tair MDB on DRAM, because running on DRAM automatically assumes that this critical section has a low overhead. However, this assumption becomes untrue when using NVM. A common problem with using new media is that assumptions which are valid in previous software processes may no longer apply in a new medium, and procedures must shift to account for this. In this case, the Tair team recommends employing lock-free design wherever possible (based on data storage) when using NVM in caching services. This limits access to the critical section and avoids cascading connection effects caused by higher latency. Tair MDB made most operations on the access path lock-free by introducing user space RCU, which significantly reduced the influence of NVM latency on upper layers. The third rule: Implement an appropriate allocator Allocators are fundamental components in transactions using NVM. The concurrency of allocators directly impacts the efficiency of the software, and the space management of allocators determines the space utilization rate. Designing and implementing allocators suited to specific software contexts is crucial in caching services using NVM. Tair MDB studies show that allocators suitable for use with NVM must offer the following functions and features: · Defragmentation: NVM is dense and has a large capacity. As a result, NVM wastes more space than DRAM under the same fragmentation ratio. The existence of the shard finish mechanism requires that upper layer apps avoid in-place updating and that allocators allocate spaces of fixed size wherever possible. · A threadlocal quota: Similar to when reducing accesses to the critical section as discussed above, the latency of allocating resources from global resource pools will reduce the concurrency of allocation operations unless there is a quota for threadlocal. · Capacity awareness: Allocators need to interpret the spaces they manage, and caching services must scale the spaces they manage accordingly. Allocators therefore must feature corresponding functions to meet those demands. Experiments have shown the above design rules are both feasible and effective in real application scenarios and can be extended to other products where NVM implementation could prove beneficial. Looking forward As discussed in previous sections, Tair MDB still treats NVM as a volatile device, reducing the overall cost of services due to NVM’s high density and low price. Going forward, the Tair team will pursue new hardware and methods for capitalizing on NVM’s non-volatility, enabling transactions and other upper layer services. (Original article by Fu Qiulei付秋雷) If you are interested in contributing to Alibaba’s work on Tair, the group is currently welcoming applications from engaged developers at the Alibaba recruitment page . References: [1]https://github.com/pmem [2]https://github.com/memkind/memkind [3]https://github.com/opcm/pcm [4]https://software.intel.com/en-us/articles/pin-a-dynamic-binary-instrumentation-tool [5] Uncovered Technology! Tair, Distributed Caching System That Handles Thousands of Billions of Visits on Double 11 [6] Persistent Memory Programming: The Current State of the Ecosystem (http://storageconference.us/2017/Presentations/Rudoff.pdf) [7] Persistent Memory: What’s Done, Coming Soon, Expected Long-term (https://blog.linuxplumbersconf.org/2015/ocw/system/presentations/3015/original/plumbers_2015.pdf) Alibaba Tech First hand and in-depth information about Alibaba’s latest technology → Facebook: . Twitter: . “Alibaba Tech” “AlibabaTech”

Going on a Tair: A Guide to NVM Caching Optimization

The Rise and Fall of Mt. Gox — What’s in your Bitcoin Wallet?

Picture from http://blog.linguistica-international.com/4-ways-translation-can-send-your-roi-through-the-roof/ Having worked on both sides of the fence, I want to share my biggest lessons learnt during my career that entailed: being a penetration tester and red teamer being an accomplished bug bounty hunter working as an internal QA engineer, Security Engineer and Security Architect a’ka blue teamer running and maintaining bug bounty program for a handful of companies worked as a head of security reporting to the board of directors for maximum ROI of security initiatives, including penetration tests and bug bounties Here is a list of action items I recommend you to take during and after penetration test/bug bounty cycle. This list is based on the most common gaps I’ve noticed at the companies I’ve worked with and the things that to me made a huge impact ROI-wise. By implementing these steps, you’ll be able to get much higher return of investment from penetration tests. If you’ve already spend your money, let’s make sure you’ve spent it well and squeezed max out of it. Provide all information to pentesters as beforehand. You want to make sure that pentesters don’t waste too much of their time on reconnaissance. Provide them with documentation on the product, video recording how your product works, and a list of APIs and endpoints you want them to test. In general, penetration testers will know what to go after, however if you have hidden APIs, or want to speed up the process, it’s better if you provide them the information beforehand. 2. Don’t play games and don’t block pentesters as they do their job. You’re all in the same team and should share the common goal to make your organization safer The mindset shift is a huge thing. I’ve met number of security teams, that were literally fighting with external pentesters, because they were afraid of their position and ego. You hire pentesters to do the work for you and to provide maximum value to your business, so it’s not smart to waste your money while you argue with pentesters and block their testing environments. Depending on corporate culture, it may be a good idea to have a separate — such as compliance/audit — team to coordinate external testing, to avoid conflict of interest. 3. Be humble and thoroughly follow pentesters recommendations in terms of issues remediation Don’t fight it, when pentesters provide you information about the issue severity and its guidance. It may sometimes happen that with internal business knowledge, you can perform better risk analysis and assess that the issue has different severity for you. However, keep in mind that most often than not, pentesters know what they’re doing and it’s not their first assessment(I hope!) so when they provide you an information about the issue, it’s likely to be legitimate. It’s generally good idea to follow their remediation guidance, to make sure you’ve addressed the issue in-depth and then request re-tests. 4. Find the root cause of every single issue and learn what you can do better next time. Stay focused on the big picture and think about other places where the same issue may exist but wasn’t found by pentesters. As opposed to simply fixing individual bugs, dig deeper into your codebase to find out if the same issue doesn’t happen in other applications. Then review your software engineering practices to see what could be done better to stop those bugs from appearing in the first place. 5. Have your engineering teams learn from pentesters and study pentest report Don’t keep it all for yourself and have everyone learn from the report. Use it as an interesting exercise and learning experience. Pentests at most companies happen once or twice per year, so why not maximize the outcome. Thanks to that software and QA engineers can learn how to apply that knowledge in their day to day work such as to add it to existing test cases. 6. Ensure developers have complete understanding of all issues You need to take ownership over the reports and don’t just throw it at employees. You want to make sure everyone has good grasp of security awareness, so they can address them well as well as use that knowledge in the future to build more robust apps. If something is complicated it won’t get easily remembered and put into action. 7. Cover identified bugs with solid regression test cases You don’t want pentesters to find the same bugs over and over again. Not only it’s a waste of money, but that’s an additional exposure, because if regression pops up, attackers may abuse it before your next pentesting engagement. We’re performing penetration tests to improve our products and company, so if you’re not going that extra mile, you’re leaving a lot on the table. 8. Once in a while check changes made by pentesters, visit their profiles used for testing to catch unexpected regressions. It makes a lot of sense to clone the activities that were performed by pentesters, and build standalone testing scenarios out of it. When you login to the pentesters’ account in the testing environment, you may notice much more bugs than they reported. Security testers, focus on reporting security issues, and most often don’t waste their time on reporting UI/UX issues, that may have been identified during security tests. So just checking their environment to see if e.g. not expected encoding didn’t break the UI, will be beneficial, and again will be something to share with internal QAs so they can improve their test cases. 9. Review logs to catch unidentified bugs Some things aren’t exposed to the user, which means that security testers may have touched some fragile system and maybe had even broken it, but they weren’t aware of it. If you review the logs, you may be able to find some unhandled exceptions, Internal Server Errors, and other indicators that may allow you to improve robustness of your code and systems. Thanks to making yourself comfortable with the logs generated by penetration testers, you’ll be also able to create security monitoring around your access/application logs, to detect potentially malicious hacking attempts. If some keywords happened to appear in logs only during pentesting engagement and never before, then attackers may perform tests in the same fashion. If you create alerting around that, you may be able to spot the attackers and allow yourself to respond to the threat. In my career I’ve met only a handful of companies that taken such wide range of activities during penetration tests. If you follow this guidance, you’ll optimize your spendings and should be more satisfied with general return of investment in security tests.

TOP 9 Rules To Maximize ROI Of Bug Bounties And Penetration Tests

Everything You Want to Know About Job Applications

The React Blog Series: Part Five This article is part five in a weekly series on building a blog with React and is an extension of the code created in previous parts. The React Blog Series Replacing Redux Thunks with Redux Sagas ( ) Writing Unit Test for a React Blog with Redux Sagas Building a website with React and Bulma Part One: Building a Blog with React and Contentful Part Two: Import your Medium Feed into React Part Three: Adding a Redux to a React Blog Part Four: Part Five: Part Six: In Progress First of all, let me start with on this subject. I have only actually been using Sagas for the last two weeks. If you’re anything like me, as you read this, you will constantly be asking yourself, why the hell would anyone want to use this, it’s massive overkill, and you would be absolutely correct. It is overkill… for what I’m doing, but at the end of the day Sagas are better, more scalable, and infinitely easier to unit test which we will see in Part Six. If you don’t like my explanations or examples, I understand. There is also SO MUCH more to Sagas than what I’m going to use here. Good Luck! — I am by no means an expert Here is the link to the Redux Saga documentation. Aaron Klaser What is Redux Saga? Sagas are a redux middleware that handles triggered in your application often referred to as ‘ . They are constantly watching for certain actions to be dispatched, before they but in and take over controller of the situation. asynchronous actions side effects’ Sagas are implemented as that objects to the redux-saga middleware. Generator functions yield Wait, what is a Generator function? !@#$ing magic, thats what! But, heres a better explanation which I stole from . Mozilla Generators are functions which can be exited and later re-entered. Their context (variable bindings) will be saved across re-entrances. Calling a generator function does not execute its body immediately; an object for the function is returned instead. When the iterator’s method is called, the generator function's body is executed until the first expression, which specifies the value to be returned from the iterator or, with , delegates to another generator function. The method returns an object with a property containing the yielded value and a property which indicates whether the generator has yielded its last value as a boolean. Calling the method with an argument will resume the generator function execution, replacing the expression where execution was paused with the argument from . iterator next() [yield](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield "The yield keyword is used to pause and resume a generator function (function* or legacy generator function).") [yield*](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/yield* "The yield* expression is used to delegate to another generator or iterable object.") next() value done next() yield next() A statement in a generator, when executed, will make the generator . If a value is ed, it will be passed back as the . A generator which has returned will not yield any more values. return done return value Okay, Back to Sagas Now where was I? Ah yes… Sagas are implemented as Generator functions that objects to the redux-saga middleware. The yielded objects are a kind of instruction to be interpreted by the middleware. When a Promise is yielded to the middleware, the middleware will suspend the Saga until the Promise completes. Once the Promise is resolved, the middleware will resume the Saga, executing code until the next yield. yield Redux Saga middleware does a lot of the Generator magic for us behind the scenes yielding to saga functions like put, all, call, and takeLatest. What happens is that the middleware examines the type of each yielded Effect then decides how to fulfill that Effect. If the Effect type is a then it will dispatch an action to the Store. If the Effect is a then it'll call the given function. This separation between Effect creation and Effect execution makes it possible to test our Generator in a surprisingly easy way using PUT CALL next() In short, are pause able functions like a music track, and are the DJ that press the pause play and stop buttons on the track. Generators Sagas But enough chit chat, let’s get started! Install Saga npm install redux-saga Then in let’s connect Saga. Saga is a redux middleware so we will be injected it into our redux applyMuiddleware function, but we will have to create it first. store/index.js import { createStore, applyMiddleware } from 'redux'import { rootReducer } from './rootReducer'import reduxImmutableStateInvariant from 'redux-immutable-state-invariant'import thunk from 'redux-thunk'import { composeWithDevTools } from 'redux-devtools-extension'; import createSagaMiddleware from 'redux-saga' const sagaMiddleware = createSagaMiddleware() export function configureStore() {return createStore(rootReducer,composeWithDevTools(applyMiddleware( thunk,reduxImmutableStateInvariant())))} sagaMiddleware, As of right now, this does nothing. We will need to initialize the sagas which need some set up before we can do that. We are going to basically gut our current thunk setups. Creating Our Saga Helpers We are going to use three helpers: helper, which will generate a type object with pending, success, and error. createAsyncTypes helper, which will generate our actions for us. createActions helper which we will use to replace our switch statements. createReducer In the folder create a file called store Utilities.js _///////////////////// ActionHelpers /////////////////////_const asyncTypes = {PENDING: 'PENDING',SUCCESS: 'SUCCESS',ERROR: 'ERROR'} export const = typeString =>Object.values(asyncTypes).reduce((acc, curr) => {acc[curr] = `${typeString}_${curr}`return acc}, {}) createAsyncTypes export const =(type, payload = {}) =>({ type, ...payload }) createAction _///////////////////// createReducer /////////////////////_export const =(initialState, handlers) =>(state = initialState, action) =>handlers.hasOwnProperty(action.type)? handlers[action.type](state, action): state createReducer I might revisit these in the future, I’m not 100% sold on the approach yet, but for now it works and it’s pretty clean createReducers Moving from Thunks to Sagas Update Blog Types Open store/blog/types.js Before, we only had 2 types, we used BLOG_LOADING to set the loading state for both complete and error, and LOAD_BLOG_SUCCESS to load our data on success. --- BEFORE --- export const BLOG_LOADING = 'BLOG_LOADING'export const LOAD_BLOG_SUCCESS = 'LOAD_BLOG_SUCCESS' /** * Blog Types */ But now, we are going to call our new help to createAsyncTypes which will create our three types automatically; Pending (loading ), Success (load data), Error (loading complete). --- After --- _*/_ { createAsyncTypes } from './../Utilities' /** * Blog Types import GET_BLOG_ASYNC createAsyncTypes('GET_BLOG') //Using ASYNC as a convention to know that I'll have three types. export const = This will make more sence in a moment. Update Blog Reducer Open store\blog\reducer.js This can be done one of two ways, we could just simply update the types in the switch cases to use the new type names we just created like this. switch (action.type) {case types. :return {...state,loading: true}case types. :return {...state,posts: action.posts,loading: false}case types. :return {...state,loading: false}default:return state} GET_BLOG_ASYNC.PENDING GET_BLOG_ASYNC.SUCCESS GET_BLOG_ASYNC.ERROR This is an example of what our types helper has done. It generated a type object with 3 values and using the convention _ASYNC we know that will contains PENDING, SUCCESS, and ERROR. createAsyncTypes GET_BLOG_ASYNC Let’s make this a little bit more intelligent by using out createReducer helper and passing it an object instead of a switch statement. Delete everything and paste in this _/*** Blog Reducer*/_import initialState from './../initialState'import { createReducer } from './../Utilities'import * as types from './types' export default createReducer(initialState.blog, {[types.GET_BLOG_ASYNC.PENDING](state) {return {...state,loading: true}},[types.GET_BLOG_ASYNC.SUCCESS](state, action) {return {...state,posts: action.posts,loading: false}},[types.GET_BLOG_ASYNC.ERROR](state) {return {...state,loading: false}}}) Yes, I know what your thinking and I agree. This does look more confusing then a switch statement and just as clean. It actually took me a minute to understand what that object was actually doing because it wasn’t something I had ever written out like this we before. It’s creating an object that each equals and an anonymous functions but it’s setting the keys using square brackets. obj = {key: fn,[key]fn} Or you can use arrow functions which you will need to a colon arrow and parentheses around the object. export default createReducer(initialState.blog, {[types.GET_BLOG_ASYNC.PENDING] (state) {...state,loading: true} ,[types.GET_BLOG_ASYNC.SUCCESS]:(state, action) => ({...state,posts: action.posts,loading: false}),[types.GET_BLOG_ASYNC.ERROR]:(state) => ({...state,loading: false})}) : => ( ) Which ever way you choice is fine, let I said I’m not 100% on board , but I think this can help create an async reducer creator in the future ;) yet Create Our First Saga In our folder create a file called store\blog sagas.js _/*** Blog Sagas*/_import * as contentful from 'contentful'import { all, call, put, takeLatest } from 'redux-saga/effects'import { actions } from './../Blog'import * as types from './types' const client = contentful.createClient({space: 'qu10m4oq2u62',accessToken: 'f4a9f68de290d53552b107eb503f3a073bc4c632f5bdd50efacc61498a0c592a'}) const fetchPosts = () => client.getEntries() function* getBlogPosts() {try {const posts = yield call(fetchPosts)yield put(actions.success(posts.items))} catch (e) {console.log(e)yield put(actions.error(e))}} export default function* () {yield all([takeLatest(types.GET_BLOG_ASYNC.PENDING, getBlogposts)])} So, what is this doing? Well, let’s start with the obvious. is my connection to my Contentful client calls our to Contentful to retrieve my posts and returns them as a Promise fetchPosts is our actual saga. It first yields the call to fetchPosts, saga magic kicks in and pauses the function and waits for Contentful to return the data. Then, once the data has been successfully returned, instead of returning a promise it actually return the data to and calls behind the scenes which tells the function to play again. It then calls which magically dispatches the the actions with the post items. If where to fail, an exception is thrown which triggers the catch. getBlogPosts const posts next() yield put fetchPosts() is the action watcher that is connected to the Redux Saga middleware. This is similar to trigger the actions, except instead of the call an action and the action being dispatched to the reducer, the saga watches for that actions to be called, then it intercepts and calls the saga. takeLatest tells Redux Saga to stop any previous running saga task if still running then run a new one. export default function* says when the action is called, stop any getBlogPosts tasks previously call that my be not be completed and call a new function. takeLatest(types.GET_BLOG_ASYNC.PENDING, getBlogPosts) types.GET_BLOG_ASYNC.PENDING getBlogPosts() The function is a kind of housing to hold all of our watchers for the blog sagas. If we have more actions, we could create more sagas and create more watchers to call those sagas, those additional watchers would go in side the all function. yield all We then export the default function, which creates gets injected into bound to the sagaMiddleware.run function in the rootSaga. Setting Up the rootSaga We need to add all our sagas to the sagaMiddleware so we can start all of our watchers when the app loads. In the folder, create a file called store rootSaga.js import blog from './blog/sagas' const sagas = [blog] export const initSagas = (sagaMiddleware) =>sagas.forEach(sagaMiddleware.run.bind(sagaMiddleware)) Right now, we only have the one saga. If we set up the Medium store with Saga’s then we would import medium and pass it in to the sagas array. we don’t need to import every function from our file, only t action watchers, which we wrapped in an all function which like like a reducer for your sagas. Note: blog/saga.js Actions, The New Face of Blog Now, that we have some sagas that can watch our actions we need to update our now out of data actions. If you have been reading along, you know that I follow the which in the case of the means the is my public app facing code, and everything in the folder is private to the store. Sagas aren’t called by the app, the actions are. currently contains our thunks but those are not necessary anymore, so we can delete them and replace them with the actions that the app will call that will trigger our sagas. We can then remove the file from our folder. fractal file structure store store/Blog.js store/blog store/Blog.js actions.js store/blog Here is the before and after of the file Blog.js --- Before --- import * as contentful from 'contentful'import * as actions from './blog/actions' const client = contentful.createClient({space: 'qu10m4oq2u62',accessToken: 'f4a9f68de290d53552b107eb503f3a073bc4c632f5bdd50efacc61498a0c592a'}) export function loadBlog() {return dispatch => {dispatch(actions.blogLoading())return client.getEntries().then(({items}) => {dispatch(actions.loadBlogSuccess(items))}).catch(error => {console.log(error)dispatch(actions.blogLoading(false))})}} We get rid of all that logic because that the Saga’s job now, and replace it with a simple actions object that out app can call. --- After --- import { createAction } from './Utilities'import * as types from './blog/types' export const actions = {pending: () => createAction(types.GET_BLOG_ASYNC.PENDING),success: (posts) => createAction(types.GET_BLOG_ASYNC.SUCCESS, { posts }),error: (error) => createAction(types.GET_BLOG_ASYNC.ERROR, { error })} The function doesn’t really do anything more then clean our code up by make it so that no matter how many things are actually passed in as the payload, this function always takes 2 arguments. I think in the future we can use this to help automate some of our async CRUD processes. createAction One Last Thing, Initialize The Sagas In our store/index.js ...import createSagaMiddleware from 'redux-saga' import { initSagas } from './rootSaga' const sagaMiddleware = createSagaMiddleware() export function configureStore() { createStore(rootReducer,composeWithDevTools(applyMiddleware(sagaMiddleware,thunk,reduxImmutableStateInvariant())))**initSagas(sagaMiddleware) const store = return store**} Originally, we were return createStore, but initSagas need sagaMiddleware to be initialized first. So, we need to create the store then pass sagaMiddleware to initSages which will start all our watchers. Instead doing something complex in the application root index to call initSagas we can just set a store variable to createStore, then call initSagas before return the store. That’s it! Granted, I only just barely scratched the surface of what Sagas can do, this is a good primer to getting them set up and actually working. Let’s Review We Installed Sagas We created some helpers for types and reducers. Updated our types Updated our reducer and learned some new technics Created our first saga Set up a rootSage Moved our actions to the public class Initialized our Saga on app loaded Yes this is way more complicated, and a fair of extra set up, and has kind of a step learning curve, and…. well you get the idea. But, it’s ultimately a better solution. It’s cleaner(ish), more scalable, more controllable, it’s real-time ready, and it’s infinitely easier to test which we will see in my article 😉 next() — Writing Unit Test for a React Blog with Redux Sagas Next

Stories, News & Mentions about BLOGLOVIN

Bloglovin’s Stories on HackerNoon

Bloglovin's News & Mentions