ShoppinPal is building the largest, most open and affordable portfolio of intelligent connectors across SME B2B Cloud systems to enable millions of businesses achieve automated operational data flows and instantly connect any number of apps

ShoppinPal

We've seen many new developments and innovations within the blockchain space over the years. 2022 has seen some interesting innovations in particular. So, let's look at some essential developments within the crypto space this year. Web3, the Next Stage of the Internet, Is Growing When discussing the development of blockchain technology in more detail, it is impossible to avoid at some point bringing up Web3. Most people believe Web3 will be the most significant factor influencing how the internet evolves over the next several years. In terms of growth, the Web3 blockchain market is expected to bring in by 2028. $23.3 billion Web3 is a version of the internet that does not have a central server and is accessible to everyone. People and organizations in this form of the internet may collaborate to operate the services that everyone uses. It is considerably different from Web2, which is now the most popular version of the internet. Web2 is controlled by large corporations such as Meta (formerly Facebook), Amazon, and Alphabet (Google's parent company), which provide popular but centralized services and have significant power over users and their personal information. and create an internet where users have more ownership, free from censorship and privacy issues. Web3 aims to change this Blockchain is one of Web3's most crucial technologies. It functions similarly to a shared ledger and may be used for various purposes, including financial transactions and smart contracts. In addition, it sets the framework for many of the platform's most essential features, such as the ability to have both fungible (i.e., cryptocurrency) and non-fungible tokens (NFTs) and a large variety of various types of decentralized apps (i.e., DEXs, borrowing/lending protocols and more). Shopping.io integrates EQX token for crypto-based online retail , a leading regulated global Defi services platform backed by EQIBank, integrates its $EQX token with crypto-to-retail bridge . Through the integration, EQIFi users can use $EQX to buy goods at some of the world’s top e-commerce platforms, including Amazon, eBay, Walmart, and Home Depot. EQIFi Shopping.io Inflation in the in May 2022—the highest rate since 1982 and, according to BBC News, one of the highest rates in the world today. This, in turn, has forced central banks to hike interest rates, leaving financier’s scratching their heads in their attempt to predict the length of the current recession. In addition, consumers have felt the brunt of this recession, with many now searching for new, innovative ways to use their assets to optimize their financial standing and purchasing power. U.S. reached 8.6% EQIFi’s partnership with Shopping.io allows users to spend their $EQX staking rewards seamlessly while enjoying seven days of free international shipping and a 2% discount on all orders for 30 days starting August 15. In addition, both ERC-20 and BEP-20 versions of $EQX can be used as forms of payment through Shopping.io’s payment processor, ShoppingPay. Shopping.io currently fulfills orders from Amazon, eBay, Walmart, and Home Depot, though this merchant list stands to grow with the launch of Shopping.io’s Web Extension. In addition, the Web Extension will allow Shopping.io to collaborate with a plethora of new merchants, aiding the expansion of $EQX’s purchasing capabilities to the farthest reaches of the web. EQIFi makes Defi as accessible as regular online banking, offering users a convenient platform incorporating the largest array of financial services in the Defi space. Backed by a licensed bank, the platform grants its clients the certainty and security that comes with the highest level of regulatory compliance. EQIFi’s relationship with EQIBank also cements it as one of the most efficient gateways between Defi and traditional finance, providing its users with a streamlined crypto/fiat On/Off ramp for greater control over their finances. “EQX token has been the backbone of our platform, and with this partnership now, it becomes part of something even bigger,” says Brad Yasar, CEO of EQIFi. “We offer our users an opportunity to grow their money through Defi, and now they can spend it at the world’s top retailers, which don’t even officially accept crypto.” “This collaboration with EQIFi brings us closer to our vision of a future where people have the flexibility to buy anything with everything,” says Arbel Arif, Founder, and CEO of Shopping.io. “The time has come for the liberation from traditional forms of payment! Consumers deserve the freedom to spend their money however they see fit. Shopping.io is committed to helping them do that.” The Metaverse Is Here to Stay Since Facebook announced the Meta rebranding in 2021, interest in the metaverse has been steadily growing. Today, the metaverse market's value is estimated to reach by 2024, up from its previous estimate of $478.7 billion in 2020. $800 billion Decentralized Autonomous Organizations (DAOs) will play a part in creating and managing the many metaverses we'll see. DAO members will use blockchain-native tokens to vote on how their specific metaverse world should be governed and developed. Metaverses can also bring many offline events and programs into the digital space. For example, users could engage in online shopping via a virtual store where users pay for goods using tokens. In addition, digital goods can be shipped directly, users can send blockchain-based assets to your wallet, and real-world goods can be linked to digital tokens and fulfilled offline. While users may use the metaverse for various purposes, the primary premise is a digital world where real-world activities take place, such as virtual meetings, consultations, and more. The metaverse is made up of a plethora of 3D environments that users may explore and interact with. It enables individuals and organizations to connect, communicate, play, and participate in online events. The metaverse is also growing in popularity within the gaming industry. expressed an interest in using crypto within the metaverse. 34% of gamers Conclusion The crypto space continues to grow and innovate as blockchain technology matures. So as time goes on, we'll hopefully see more innovations and projects within the industry.

Interesting Events That Are Happening in the Crypto Space 2022

is a .NET library that provides use with a bunch of useful extension methods that allow us to test our C# code in a more natural way. Fluent Assertions Let's say for example we are testing the output of a string. Without Fluent Assertions, we might write something like this: string testString = "hello";
string expectedOutput = testString.ToUpper();
Assert.Equal(expectedOutput, "HELLO"); If we were to write this test using Fluent Assertions, we could do so like this: string testString = "hello";
string expectedOutput = testString.ToUpper();
expectedOutput.Should().Be("HELLO"); See? Much more natural 😊 Introducing Assertion Scopes Let’s use a more extensive example. Say if I have a class that generates a shopping list like so: public class ShoppingListGenerator
    {
        public static List<Item> GenerateItems()
        {
            return new List<Item>
            {
                new Item
                {
                    Name = "Apple",
                    Quantity = 5
                },
                new Item
                {
                    Name = "Banana",
                    Quantity = 1
                },
                new Item
                {
                    Name = "Orange",
                    Quantity = 3
                }
            };
        }
    } For more complex unit tests, we may want to assert on multiple properties like so: public class ShoppingListGeneratorShould
    {
        [Fact]
        public void MultipleAssertions()
        {
            var testShoppingList = ShoppingListGenerator.GenerateItems();

            testShoppingList.Should().NotBeNullOrEmpty();
            testShoppingList.Should().Contain(new Item { Name = "Cheese", Quantity = 2 });
            testShoppingList.Should().HaveCount(10);
            testShoppingList.Should().OnlyHaveUniqueItems();           
        }
    } This approach is fine, but looking at our code, we can see that this test would fail on the assertion that our list will fail on the. method, since we don't have an item in our list that contains Cheese. This test would also fail on our. method, since we have only 3 items in our list, not 10. Contain() HaveCount() Let's confirm our thinking by running our test. We were correct! But in this example, not only has our test failed against our method, but it has stopped running our test! .Contains() Imagine that we fix this error so that the assertion passes, but then fails on the next assertion. And the next one, then the next one and so forth. Testing our code like this would be rather tedious. Thankfully we can fix this using an Assertion Scope! Using Assertion Scopes, we can batch multiple assertions into a AssertionScope so that FluentAssertions will only throw the one exception at the end of the scope with all of our failures. Let's change our test to use an Assertion Scope. using AssertionScopes;
using FluentAssertions;
using FluentAssertions.Execution;
using System;
using Xunit;

namespace Tests
{
    public class ShoppingListGeneratorShould
    {
        [Fact]
        public void MultipleAssertions()
        {
            var testShoppingList = ShoppingListGenerator.GenerateItems();

            using (new AssertionScope())
            {
                testShoppingList.Should().NotBeNullOrEmpty();
                testShoppingList.Should().Contain(new Item { Name = "Cheese", Quantity = 2 });
                testShoppingList.Should().HaveCount(10);
                testShoppingList.Should().OnlyHaveUniqueItems();
            }                     
        }
    }
} We are now wrapping our Assertions in a using statement and our exception will only be thrown at the point of disposing our AssertionScope. Let's run the test and see what happens! Our test has failed, but here we now get both exceptions thrown back to us! Message: 
    Expected testShoppingList {AssertionScopes.Item
       {
          Name = "Apple"
          Quantity = 5
       }, AssertionScopes.Item
       {
          Name = "Banana"
          Quantity = 1
       }, AssertionScopes.Item
       {
          Name = "Orange"
          Quantity = 3
       }} to contain 
    
    AssertionScopes.Item
    {
       Name = "Cheese"
       Quantity = 2
    }.
    Expected testShoppingList to contain 10 item(s), but found 3. Now instead of having to run and re-run our tests each time an assertion fails in our test, we can see all the assertions that are failing in a test at once! Conclusion Fluent Assertions is a great library that allows us to write our C# tests in a more natural and expressive way. Assertion Scopes make our lives easier when using multiple assertions within our unit tests by saving us time and effort when finding out why our tests are failing. If you want to learn more about Fluent Assertions, check out the docs here: https://fluentassertions.com/about/ Hopefully, you found this article useful! As always, if you have any questions, feel free to comment below or ask me on ! Twitter Happy Coding! 💻👨‍💻👩‍💻 Also published on: https://dev.to/willvelida/using-assertion-scopes-to-execute-multiple-assertions-3029

How to Use Assertion Scopes to Execute Multiple Assertions in C#

Our E-commerce Web App. we looked into navigating from one view to another with router which requires an anchor link and us passing the attribute to the shell but this approach requires us to keep creating component for each view, but what if there is a better approach to write codes and navigate between views without having to create a new component for each view. Previously, routerLink Today, we are going to look into that with an e-commerce like web app while interacting between a product and its checkout. Now, we have few product listed within our app but does that mean we have to create a new view for each product checkout? That could be really stressful and it makes it hard for us to manage our code base, which is why navigating imperatively seems quite the gold. With imperative navigation, we only need to create one view for the product checkout page, and bind it to the product checkout button telling router to navigate to this page and also supply the data of the product and we are actually going to do this right now step by step. If you have no idea about what router is and how to use it please refer back to my previous tutorial. Before we get started ensure you know how to do the following: - Create and define route paths - Create a service that supplies data asynchronously to our app And that’s pretty it. At the end of this tutorial, your app should function like the above image despite the absence of quality UI especially in the checkout page. Alright, I already prepared the files we need to get started alongside the UI, products data and I also created a service, so just clone this from my , run pub get and webdev serve. repository Guess we are all ready to navigate imperatively. Before diving into imperative navigation, let’s run the app to get informed about the changes and structure. For now, when the user clicks on proceed to checkout the details of the clicked product displays under the product list section just like this: Now, what we want to do is that when the user click proceed to checkout button we want it to navigate to an entire new view and for it to also show the data of the particular product clicked. The first thing we want to do is create a component for the new view which we are going to call checkout view. So let’s create a file within our lib folder and add the following code to it: checkout.dart Here we go, we’ve got our selector, template, directives and also exporting RoutePaths and Routes. If you noticed we didn’t import RoutePaths and Routes package because we already did that within the app component thereby making it available for all other components. Next we define the route path for checkout which is going to be the tricky part. So, what we want right now is for our URL to indicate the product name when the user clicks on the product like this: http://localhost:8080/#shopping/2%20by%208%20bedroom This URL indicates that the user clicked on proceed to checkout for a product with the name “2 by 8 bedroom” this can only be done with the use of Route Parameters. The syntax for route parameters is as follows: The parameters only return a String but we can also parse it to return an integer, based on the API documentation of route parameters there isn’t any clear definition of how to use it, so am also going to do that. Firstly, we want the URL to indicate shopping/”productname” but we already created a route path for shopping, so we’ll be referring to the path of shopping using . shopping.path We also want to pass in the product name, and to do that we first create a variable name of and give it a value of . idParam “products” We used the value products within the shopping page to list all items in our List, to be on the safer side I recommend you maintain one variable name within your program things might get bigger and you can’t keep track of all those variable names. Alright, let’s go ahead and create a const variable name with value products just above the class declaration of . idParam RoutePaths Next, we define the route path for checkout passing as a parameter idParam Like I mentioned earlier, we want the URL address to indicate and the proper way to go about that is referring to the path of shopping followed by a forward slash with as the route parameters. #shopping idParam Doesn’t seem like we are done, the creates a slot in the path for a route parameter which the router will insert the product name of the clicked product into that slot of ours and if we tell router to navigate to the checkout component and display the checkout details for the product with product name 2 by 2 bedroom, price of 300$ and the description, the URL should look just like this: idParam http://localhost:8080/#shopping/2%20by%208%20bedroom If the user also enters the above URL into the address bar directly it navigates to the checkout page of that product like I explained earlier. The property has a map of URL parameters of type String such that if the matched path has a path ‘shopping/:productName’ and the URL is ‘shopping/2by2bedroom’, the router parameters would equal {productName: ‘2by2bedroom’}. RouterParameters RouteDefinition Up next is getting the name of the product clicked and passing it into the Route parameters. Within our file we create a method that returns a String value and receives a parameter of router parameters. route_path.dart getName() The method returns the value for the given [product] or null if [product] is not in the map. Some maps allow keys to have null as a value so we also condition it to return null if the product equals null and if false it returns the products name which is a String parameter. getProducts() If you’re trying to return an integer and we are quite aware that route parameters receives a String we use method to parse the item into an integer just like the below code: tryParse( source ) Moving forward, we define the checkout route path in the same conventional way we define route paths for other view: Now, we are all set up to implement all the checkout routes to be navigated imperatively. Let’s switch our dart file to the components that hold the list of all products which is the file. We won’t be adding any to proceed to checkout anchor link tag instead we would be navigating imperatively with the use of router. But first we initialize Router within our class shopping.dart routerLink ShoppingComponent After initializing the router, we create a private method since it’ll be initialized and it holds the checkout view URL and also passing the required parameters to the checkout path: takes a String parameter of products because our product name is a String and like I mentioned earlier — _checkoutUrl maintain a variable name when navigating imperatively. The uses the arrow syntax to pass in the URL of the checkout route path alongside the necessary parameters. chechoutUrl So, we want to tell router to navigate automatically when something happens and in this case when the user clicks proceed to checkout button. The Future is used to delay computation when calling and the holds the result of calling which attempts to navigate to the defined path and in this case is the checkout path. router.naviagate NavigationResult router.navigate We defined a String parameter of the products that is the product name in the method. _checkoutUrl() Earlier on, we initialized method that responds to a click event and returns the data of the clicked product storing it in the variable of type class . onSelect() selectedProduct Products But we don’t want to display the selected product below the products list anymore, we just want to display the selected product in another view therefore we pass in the products parameter to the , which gives us the leverage to refer to that particular product name. _checkoutProduct() That’s it; we are done interacting with the shopping component, the rest lies within the checkout view component but let’s head over to the shopping component HTML file and cut out the selected product section. We are going to paste this section into the template property of our checkout component. selectedProduct Quickly, let’s add into our directives and import the dart file. ShoppingComponent ShoppingComponent Within our class, we initialize and which interacts with the browser URL and will also be used to navigate back to the shopping page; we also declare a variable name of type class which is the same variable within the attribute within the template. CheckoutComponent Product service Location selectedProduct Products *ngIf We implement lifecycle hook on the class. onActivate CheckoutComponent is a lifecycle interface which notify when a component is activated by a route. Component classes should implement this if they will be navigated to as part of a route definition and would like to be notified if they were activated due to routing. onActivate After implementing we create an override annotation to override the method onActivate onActivate We replace previous with an underscore ( ), which is called after the component is inserted by a router outlet and will occur after initial change detection. RouterState _ Next we add this block of code within the method: onActivate The returns the product current value from the route path and if the product is not equal to null, we get the products assigning it to the variable name . getProduct(current.parameters) selectedProduct We haven’t initialized the method which will only be done within the product service class. get() The indicates an asynchronous operation, so we add to the method, which fetches the product data asynchronously. await async onActivate() Lastly, we head to the product service class and add a method that fetches the data asynchronously from the list of products while iterating the list to fetch the selected product name where it first occurs in the list. get Yeah, that settles it and our app works fine so why not use navigating imperatively in your….. One more thing, let’s look at how can be useful. Location Within our checkout page am going to add a “ ” button that navigates the user back to the previous page using location.back back to shopping Add this piece of HTML code to your template of your checkout page and add this piece of code within the class implementing the click event CheckoutComponent goBack() The location class can navigate back and forward in a platform (browser) history. Yeah, back to what I was saying. That settles it and our app works fine so why not use navigating imperatively in your next e-commerce web app or any app of your choice like a blog also.

Navigating Imperatively With Angular Dart In An E-commerce Web App

Mutability of Collections: Arrays Swift // creata an empty arrayvar someInts = [Int]()print("someInts is of type [Int] with \(someInts.count) items.")// Prints "someInts is of type [Int] with 0 items." // Creating an Array with a Default Valuevar threeDoubles = Array(repeating: 0.0, count: 3)// threeDoubles is of type [Double], and equals [0.0, 0.0, 0.0]var anotherThreeDoubles = Array(repeating: 2.5, count: 3)// anotherThreeDoubles is of type [Double], and equals [2.5, 2.5, 2.5] var sixDoubles = threeDoubles + anotherThreeDoubles// sixDoubles is inferred as [Double], and equals [0.0, 0.0, 0.0, 2.5, 2.5, 2.5] // Creating an Array with an Array Literalvar shoppingList: [String] = ["Eggs", "Milk"]// shoppingList has been initialized with two initial items // Accessing and Modifying an Arrayif shoppingList.isEmpty {print("The shopping list is empty.")} else {print("The shopping list is not empty.")}// Prints "The shopping list is not empty."shoppingList.append("Flour")// shoppingList now contains 3 items, and someone is making pancakesshoppingList += ["Baking Powder"]// shoppingList now contains 4 itemsshoppingList += ["Chocolate Spread", "Cheese", "Butter"]// shoppingList now contains 7 itemsvar firstItem = shoppingList[0] // firstItem is equal to "Eggs"shoppingList[0] = "Six eggs"// the first item in the list is now equal to "Six eggs" rather than "Eggs" shoppingList[4...6] = ["Bananas", "Apples"]// shoppingList now contains 6 items shoppingList.insert("Maple Syrup", at: 0)// shoppingList now contains 7 items// "Maple Syrup" is now the first item in the list let mapleSyrup = shoppingList.remove(at: 0)// the item that was at index 0 has just been removed// shoppingList now contains 6 items, and no Maple Syrup// the mapleSyrup constant is now equal to the removed "Maple Syrup" string let apples = shoppingList.removeLast()// the last item in the array has just been removed// shoppingList now contains 5 items, and no apples// the apples constant is now equal to the removed "Apples" string // Iterating Over an Arrayfor item in shoppingList {print(item)}// Six eggs// Milk// Flour// Baking Powder// Bananas for (index, value) in shoppingList.enumerated() {print("Item \(index + 1): \(value)")}// Item 1: Six eggs// Item 2: Milk// Item 3: Flour// Item 4: Baking Powder// Item 5: Bananas JavaScript // creata an empty arraylet someInts = new Array()console.log(`someInts is an array with ${someInts.length} items.`)// Prints "someInts is an array with 0 items." // Creating an Array with a Default Valuelet threeDoubles = [0.0, 0.0, 0.0]// threeDoubles is of type [Double], and equals [0.0, 0.0, 0.0]let anotherThreeDoubles = [2.5, 2.5, 2.5]// anotherThreeDoubles is of type [Double], and equals [2.5, 2.5, 2.5] let sixDoubles = [...threeDoubles, ...anotherThreeDoubles]// sixDoubles is inferred as [Double], and equals [0.0, 0.0, 0.0, 2.5, 2.5, 2.5] // Creating an Array with an Array Literallet shoppingList = ["Eggs", "Milk"]// shoppingList has been initialized with two initial items // Accessing and Modifying an Arrayif (shoppingList.length === 0) {console.log("The shopping list is empty.")} else {console.log("The shopping list is not empty.")}// Prints "The shopping list is not empty."shoppingList.push("Flour")// shoppingList now contains 3 items, and someone is making pancakesshoppingList = shoppingList.concat(["Baking Powder"])// shoppingList now contains 4 itemsshoppingList = [...shoppingList, "Chocolate Spread", "Cheese", "Butter"]// shoppingList now contains 7 itemslet firstItem = shoppingList[0]// firstItem is equal to "Eggs"shoppingList[0] = "Six eggs"// the first item in the list is now equal to "Six eggs" rather than "Eggs" shoppingList.splice(4, 3, "Bananas", "Apples")// shoppingList now contains 6 items shoppingList.unshift("Maple Syrup")// shoppingList now contains 7 items// "Maple Syrup" is now the first item in the list let mapleSyrup = shoppingList.shift()// the item that was at index 0 has just been removed// shoppingList now contains 6 items, and no Maple Syrup// the mapleSyrup constant is now equal to the removed "Maple Syrup" string let apples = shoppingList.pop()// the last item in the array has just been removed// shoppingList now contains 5 items, and no apples// the apples constant is now equal to the removed "Apples" string // Iterating Over an ArrayshoppingList.forEach((item => {console.log(item)})// Six eggs// Milk// Flour// Baking Powder// Bananas shoppingList.forEach(((item, index) => {console.log(`Item ${index + 1}: ${value}`)})// Item 1: Six eggs// Item 2: Milk// Item 3: Flour// Item 4: Baking Powder// Item 5: Bananas Sets Swift // Creating and Initializing an Empty Setvar letters = Set<Character>()print("letters is of type Set<Character> with \(letters.count) items.")// Prints "letters is of type Set<Character> with 0 items."var favoriteGenres: Set<String> = ["Rock", "Classical", "Hip hop"]// favoriteGenres has been initialized with three initial items // Accessing and Modifying a Setprint("I have \(favoriteGenres.count) favorite music genres.")// Prints "I have 3 favorite music genres." if favoriteGenres.isEmpty {print("As far as music goes, I'm not picky.")} else {print("I have particular music preferences.")}// Prints "I have particular music preferences." favoriteGenres.insert("Jazz")// favoriteGenres now contains 4 items if let removedGenre = favoriteGenres.remove("Rock") {print("\(removedGenre)? I'm over it.")} else {print("I never much cared for that.")}// Prints "Rock? I'm over it." if favoriteGenres.contains("Funk") {print("I get up on the good foot.")} else {print("It's too funky in here.")}// Prints "It's too funky in here." // Iterating Over a Setfor genre in favoriteGenres {print("\(genre)")}// Classical// Jazz// Hip hop JavaScript // Creating and Initializing an Empty Setlet letters = new Set()console.log(`letters is of type Set with ${letters.size} items.`)// Prints "letters is of type Set with 0 items."let favoriteGenres = new set(["Rock", "Classical", "Hip hop"])// favoriteGenres has been initialized with three initial items // Accessing and Modifying a Setconsole.log(`I have ${favoriteGenres.size} favorite music genres.`)// Prints "I have 3 favorite music genres." if (favoriteGenres.size == 0) {console.log("As far as music goes, I'm not picky.")} else {console.log("I have particular music preferences.")}// Prints "I have particular music preferences." favoriteGenres.add("Jazz")// favoriteGenres now contains 4 itemsconst removedGenre = favoriteGenres.delete("Rock")if (removedGenre) {console.log(`${removedGenre}? I'm over it.`)} else {console.log("I never much cared for that.")}// Prints "Rock? I'm over it." if (favoriteGenres.has("Funk")) {console.log("I get up on the good foot.")} else {console.log("It's too funky in here.")}// Prints "It's too funky in here." // Iterating Over a SetfavoriteGenres.forEach(genre => {console.log(genre);})// Classical// Jazz// Hip hop Dictionaries Swift // Creating an Empty Dictionaryvar namesOfIntegers = [Int: String]()// namesOfIntegers is an empty [Int: String] dictionarynamesOfIntegers[16] = "sixteen"// namesOfIntegers now contains 1 key-value pairnamesOfIntegers = [:]// namesOfIntegers is once again an empty dictionary of type [Int: String] // Creating a Dictionary with a Dictionary Literalvar airports: [String: String] = ["YYZ": "Toronto Pearson", "DUB": "Dublin"] // Accessing and Modifying a Dictionaryprint("The airports dictionary contains \(airports.count) items.")// Prints "The airports dictionary contains 2 items." if airports.isEmpty {print("The airports dictionary is empty.")} else {print("The airports dictionary is not empty.")}// Prints "The airports dictionary is not empty." airports["LHR"] = "London"// the airports dictionary now contains 3 items airports["LHR"] = "London Heathrow"// the value for "LHR" has been changed to "London Heathrow" if let oldValue = airports.updateValue("Dublin Airport", forKey: "DUB") {print("The old value for DUB was \(oldValue).")}// Prints "The old value for DUB was Dublin." if let airportName = airports["DUB"] {print("The name of the airport is \(airportName).")} else {print("That airport is not in the airports dictionary.")}// Prints "The name of the airport is Dublin Airport." airports["APL"] = "Apple International"// "Apple International" is not the real airport for APL, so delete itairports["APL"] = nil// APL has now been removed from the dictionary if let removedValue = airports.removeValue(forKey: "DUB") {print("The removed airport's name is \(removedValue).")} else {print("The airports dictionary does not contain a value for DUB.")}// Prints "The removed airport's name is Dublin Airport." // Iterating Over a Dictionaryfor (airportCode, airportName) in airports {print("\(airportCode): \(airportName)")}// YYZ: Toronto Pearson// LHR: London Heathrow for airportCode in airports.keys {print("Airport code: \(airportCode)")}// Airport code: YYZ// Airport code: LHR for airportName in airports.values {print("Airport name: \(airportName)")}// Airport name: Toronto Pearson// Airport name: London Heathrow let airportCodes = [String](airports.keys)// airportCodes is ["YYZ", "LHR"] let airportNames = [String](airports.values)// airportNames is ["Toronto Pearson", "London Heathrow"] JavaScript // Creating an Empty Dictionarylet namesOfIntegers = {}// namesOfIntegers is an empty dictionarynamesOfIntegers[16] = "sixteen"// namesOfIntegers now contains 1 key-value pairnamesOfIntegers = {}// namesOfIntegers is once again an empty dictionary of type // Creating a Dictionary with a Dictionary Literallet airports = {"YYZ": "Toronto Pearson", "DUB": "Dublin"} // Accessing and Modifying a Dictionaryconsole.log(`The airports dictionary contains ${Object.keys(airports).length} items.`)// Prints "The airports dictionary contains 2 items." if (Object.keys(airports).length == 0) {console.log("The airports dictionary is empty.")} else {console.log("The airports dictionary is not empty.")}// Prints "The airports dictionary is not empty." airports["LHR"] = "London"// the airports dictionary now contains 3 items airports["LHR"] = "London Heathrow"// the value for "LHR" has been changed to "London Heathrow" const oldValue = airports["DUB"]airports["DUB"] = "Dublin Airport"if (oldValue)  {console.log(`The old value for DUB was ${oldValue}.`)}// Prints "The old value for DUB was Dublin."const airportName = airports["DUB"]if (airportName) {console.log(`The name of the airport is ${airportName}.`)} else {console.log("That airport is not in the airports dictionary.")}// Prints "The name of the airport is Dublin Airport." airports["APL"] = "Apple International"// "Apple International" is not the real airport for APL, so delete itairports["APL"] = nulldelete airports["APL"]// APL has now been removed from the dictionary // Iterating Over a DictionaryObject.keys(airports).forEach(airportCode => {const airportName = airports[airportCode]console.log(`${airportCode}: ${airportName}`)})// YYZ: Toronto Pearson// LHR: London Heathrow let airportCodes = Object.keys(airports)// airportCodes is ["YYZ", "LHR"] More of Swift and JavaScript comparison snippets

Swift and JavaScript comparison snippets(4) — Collection Types

Hi everyone! In this article I’d like to show you how to create application using . If you don’t know what Flutter is, I encourage you to read my article . However, if you know what Flutter is and you’d like to create an application that is — then keep going with reading! Flutter Redux Flutter — 5 reasons why you may love it well designed, easy to test and has very predictable behaviour What is Redux? Firstly, let’s start with explaining what is. is an application architecture, made originally for JavaScript and now used in applications built with (such as React Native or Flutter). Redux is simplified version of architecture, made by Facebook. But what’s all about with Redux? Basically, you need to know three things: Redux Redux reactive frameworks Flux there’s a — your whole application state is kept only in one place (called store) single source of truth the — to change the application state you need to dispatch an action, and then new state is created state is read-only changes are made with — a pure function (to simplify, it’s a function without side effects) takes the previous state and an action, and returns new state pure functions Sounds cool, but what are the advantages of that solution? we have — it means that we exactly know what caused state change, we don’t have duplicated state and we can easily follow data flow control over the state pure — we can pass state, action and test if result is correct reducer functions are easy to test application is — we have different layers for actions, models, business logic, etc. — so you exactly know where to put another new feature clearly structured it’s great apps — you don’t need to pass state down the whole view tree from parent to child architecture for more complicated and there’ one more… Redux Time Travel There’s one cool feature possible in Redux — 🎉 ! With Redux and you can over the time, inspect actual state and . See this feature in action: Time Travel proper tools track your application state recreate it at any time Time Travel in action — how cool is that? Redux Widgets on a simple example All of the above rules makes data flow in Redux . But what does it mean? In practice it’s all done with . Let’s imagine application that shows button counter: unidirectional actions, reducers, store and states Your application has some at the beginning (number of clicks, which is 0) state Based on that state is rendered. view If user taps on button, there’s send (e.g. IncrementCounter) action Action is received by , which knows previous state (counter 0), receives action (IncrementCounter) and can return new state (counter 1) reducer Your application has new (counter 1) state Based on new state, is rendered again view So as you can see, generally it’s . You have single app , the is read-only for view, and to create new you need to send action. Sending action fires reducer that creates and emits new application . And history repeats itself. all about the state state state state state Redux Data Flow Example of Shopping List App with Redux Let me show how Redux works in practice on more advances example. We’ll create a simple ShoppingCart application. In this application there will be functionalities for: adding items marking items as checked and that’s basically all 😎 The application will look like this: You can see the whole application code on GitHub: _FlutterShoppingCart - Flutter example of shopping app using Redux architecture_github.com pszklarska/FlutterShoppingCart Let’s start with coding! 👇 Prerequisite In this article I’ll not show creating UI for this application. You can check the code for . We’ll start with coding from this point and we’ll add Redux to this application. this Shopping List application before implementing Redux here If you’ve never used Flutter before, I encourage you to try a . Flutter Codelabs from Google Setup To run with Redux on Flutter, you need to add dependencies to your file: pubspec.yaml flutter_redux: ^0.5.2 You can check the newest version on package page. flutter_redux Model Our application needs to manage adding and changing items, so we‘ll use simple model to store single item state. . As you can see, CartItem is just a plain Dart object. CartItem Our whole application state will be just list of CartItems class {String name;bool checked; CartItem (this.name, this.checked);} CartItem Note: Here’s the full source code for this file. Actions Firstly, we need to declare . Action is basically any . In our application we’ll have two actions, for adding and changing item: actions intent that can be invoked to change application state class {final CartItem item; AddItemAction (this.item);} AddItemAction class {final CartItem item; ToggleItemStateAction (this.item);} ToggleItemStateAction Note: Here’s the full source code for this file Reducers Then, we need to tell our application what should be done with those actions. This is why are for — they simply . We’ll have two reducers methods: reducers take current application state and the action, then they create and return new application state List<CartItem> (List<CartItem> items, dynamic action) {if (action is AddItemAction) {return ;} else if (action is ToggleItemStateAction) {return ;}return items;} appReducers addItem(items, action) toggleItemState(items, action) List<CartItem> (List<CartItem> items, AddItemAction action) {return List.from(items)..add(action.item);} addItem List<CartItem> (List<CartItem> items, ToggleItemStateAction action) {return items.map((item) => item.name == action.item.name ?action.item : item).toList();} toggleItemState Note: Here’s the full source code for this file. Method delegates the action to proper methods. Both methods and return new lists — that’s our new application state. As you can see, . Instead of it, we create new lists every time. appReducers() addItem() toggleItemState() you shouldn’t modify current list StoreProvider Now, when we have actions and reducers, we need to provide place for storing application state. It’s called in Redux and it’s for our application. store single source of truth void main() { final store = new Store<List<CartItem>>(appReducers,initialState: new List()); runApp(new FlutterReduxApp(store));} Note: Here’s the full source code for this file. To create store, we need to pass methods and . If we created the store, we must pass it to the to tell our application than it can be used by anyone who wants to request app state: reducers initial application state StoreProvider class FlutterReduxApp extends StatelessWidget {final Store<List<CartItem>> store; FlutterReduxApp(this.store); @overrideWidget build(BuildContext context) { }} return new StoreProvider<List<CartItem>>(store: store,child: new ShoppingCartApp(),); Note: Here’s the full source code for this file. In the above example is main application widget. ShoppingCartApp() StoreConnector Currently we have everything except… actual adding and changing items. How to do that? To make it possible, we need to use . It’s a way to . StoreConnector get the store and make some action with it or read it’s state Firstly, we’d like to : read current data and show this in a list class ShoppingList extends StatelessWidget {@overrideWidget build(BuildContext context) {return new ( {return new ListView.builder(itemCount: list.length,itemBuilder: (context, position) => },);}} StoreConnector<List<CartItem>, List<CartItem>> converter: (store) => store.state,builder: (context, list) new ShoppingListItem(list[position])); Note: Here’s the full source code for this file. Code above wraps default with . StoreConnector can take current app state (which is ) and map this with function to anything. For purposes of this case, it’ll be the same state ( ), because we need the whole list here. ListView.builder StoreConnector List<CartItem> converter List<CartItem> Next, in function we get — which is basically list of CartItems from , which we can use for building ListView. builder list store Ok, cool — we have reading data here. Now how to set some data? To do it, we’ll use also , but in a slightly different way. StoreConnector class AddItemDialog extends StatelessWidget {@overrideWidget build(BuildContext context) {return new StoreConnector<List<CartItem>, OnItemAddedCallback>(converter: (store) { } builder: (context, callback) {return new AddItemDialogWidget( );});}} return (itemName) =>store.dispatch(AddItemAction(CartItem(itemName, false))); , callback typedef OnItemAddedCallback = Function(String itemName); Note: Here’s the full source code for this file. Let’s look at the code. We used , as in the previous example, but this time, instead of mapping list of CartItems, into the same list, we’ll map this into . This way we can pass callback to the and call it when user adds some new item: StoreConnector OnItemAddedCallback AddItemDialogWidget class AddItemDialogWidgetState extends State<AddItemDialogWidget> {String itemName; final OnItemAddedCallback callback;AddItemDialogWidgetState(this.callback); @overrideWidget build(BuildContext context) {return new AlertDialog(...actions: <Widget>[...new FlatButton(child: const Text('ADD'), ... ],);}} onPressed: () { callback(itemName);}) Note: Here’s the full source code for this file. Now, every time user press “ADD” button, the callback will dispatch event. AddItemAction() Now we can do very similar thing for toggling item state: class ShoppingListItem extends StatelessWidget {final CartItem item; ShoppingListItem(this.item); @overrideWidget build(BuildContext context) {return new (converter: (store) { }, builder: (context, callback) {return new ListTile(title: new Text(item.name),leading: new Checkbox(value: item.checked, );});}} StoreConnector<List<CartItem>, OnStateChanged> return (item) => store.dispatch(ToggleItemStateAction(item)); onChanged: (bool newValue) {callback(CartItem(item.name, newValue));}), typedef OnStateChanged = Function(CartItem item); Note: Here’s the full source code for this file. As in the previous example, we use for mapping into callback. Now every time checkbox is changed (in method), the callback fires event. StoreConnector List<CartItem> OnStateChanged onChanged ToggleItemStateAction Summary That’s all! In this article we created a simple Shopping List application using Redux architecture. In our application we can add some items and change their state. Adding new features to this application is as simple as adding new actions and reducers. Here you can check the full source code for this application, including widget: Time Travel _FlutterShoppingCart - Flutter example of shopping app using Redux architecture_github.com pszklarska/FlutterShoppingCart Hope you liked this post and stay tuned for more! 🙌

Flutter + Redux — How to make Shopping List App?

Our early virtual assistants are kind of janky. That’s okay! Three predictions on virtual assistants in a week full of predictions — from folks like us who actually build them. As people are asking “is every toaster, microwave and car going to talk to me now?” Or are virtual assistants just a fad since many are being ? voice assistants dominated CES last week, really shutdown or proclaimed dead It’s hard to tell from the news this week. Having spent the last 1.5 years (and building consumer tech), here’s the bets I’d make: building virtual assistants 20+ years : Google and Amazon will be in a lot of devices, but neither will “own” the voice entry point to customers. Prediction #1 That’s because the data and brand interactions created by conversations with customers will be so valuable that companies will not want to share this data with potential future competitors. Companies might experiment with Alexa and Google, but they are not going to totally give up on building their own voice platforms as at Axios this week at CES: Ina Fried observed It’s a fierce battle between Amazon and Google to get their assistants included on other companies’ devices. At the same time, hardware makers including Samsung, LG and Roku are (also) putting their own voice assistants into their products. As these companies watch their users interact conversationally with their hardware, they may find that the verboseness required to be a “smart speaker” like Alexa that can answer everything may not be required to enable useful conversational navigation of, say, a microwave. A smart speaker needs to be an omniscient service that can answer everything for everyone. Often a few basic like , and some base navigational phrases can help the user accomplish most tasks — especially if the device has a screen that can convey information as well. user intents ”Yes” ”No” I’m completely biased on this idea, but I believe companies will start turning to dedicated ( ) to build holistic voice and chatbot features for their businesses outside of just embedding inside the big tech NLU platforms like Alexa or Google. To be clear, I believe these proprietary services will have interoperability with the major NLUs, but will be something more than “just an Alexa skill” in the near future. plug! conversational developers Also, the companies that are experimenting with their own services now will be way ahead of the curve when their customers expect having a personalized conversation with a brand as a primary feature. Experimentation while the market is still growing and the bar to wow the end user is low is important. That’s because even though Google, Amazon and Apple have a huge lead on most speech recognition services, the most practical assistants do not need to understand a massive vocabulary to accomplish most tasks. Again, that’s because a single domain application can manage to handle the recognition of limited (cocktails, movie names, etc) within a reasonable amount of time. It can be a bit rough at first, but better to work out these issues now while the number of total users is small. If you were late to the web or mobile, don’t blow it this time by waiting to find out how to present your brand in the conversational internet. Do it now while the stakes are low. ASR entity names So expect even more voice and chat platforms outside of Amazon, Google and Facebook to exist and thrive in the marketplace over the next few years. : The conversational internet will expand and interoperability between conversational platforms will accelerate as consumers demand consistent, state-aware conversational relationships with their favorite brands across platforms. Prediction #2 Even if I’m wrong and there are not dozens of successful conversational platforms and only 3–5 conversational platforms dominate, the consumer will demand that the relationship with their favorite brands transfer state to whatever platform is convenient for them. Think streaming a movie on Netflix on multiple devices for conversations. For example, I may start talking to in the morning, but I may want to pick back up the while at work to confirm I want to make that recipe. Then I might want to when I’m shopping for ingredients later. If I have to start the conversation over again or the AI doesn’t remember what we last spoke about — even if that’s on another device or platform — that user will be irritated with the brand and think it is dumb. Alexa about a recipe in my kitchen conversation on a Slackbot pull it up on my phone There’s no reason for the consumer to ever feel like a brand is dumb just because it can’t remember what the last interaction was on a different platform. Platform lock-in will not work on the conversational internet, much like it didn’t on the web or mobile. Brands and their consumers will force openness onto these conversational platforms. The platforms that try to keep brands locked in to their platform will ultimately fade while the open ones expand… . Can you imagine how pervasive Siri would be if it was launched as an open platform? MBA’s will be writing cases about that missed opportunity for years. as usually happens The thing that is really missing for conversational services to explode is an open standards body that will enable developers and companies to build interoperability for the conversational services. More on that in another post. : Conversational assistants and chatbots are not overhyped or dying. Prediction #3 Sure, conversational assistants and chatbots have been kludgy (or ) in this first wave, but that doesn’t mean they are “dead” or dying. It means they are evolving. Yep, this is evolution and we’re seeing the or fully baked. downright offensive extinction of things that aren’t quite right It has a shell hair! Everything for eveyone! Glyptodons (above) did not make it, but armadillos did. and Every major platform change starts with . 98% of startup products deserve to be evolutionary fodder. Another 1.5% were genius ideas that were too early. The other .5% that survive become monster businesses. weird experiments or just plain bad ideas In Wired’s assistant, they lopped in “and so are chatbots” in the headline. In the vicious hype cycle of new technology, it wouldn’t be a cycle if chatbots and voice apps didn’t suffer a bit of a blowback after last few years of exuberance for those technologies. But to say that virtual assistants and chatbots are dead because the first wave of these applications are a bit wonky would be short-sighted. reporting on the “death” of Facebook’s M The Wired article by and actually lays out the real issues with not only M, but Siri and the whole first wave of all-in-one “Pangea” assistants: Erin Griffith Tom Simonite M's core problem: Facebook put no bounds on what M could be asked to do. Alexa has proven adept at handling a narrower range of questions, many tied to facts, or Amazon's core strength in shopping.Another challenge: When M could complete tasks, users asked for progressively harder tasks. A fully automated M would have to do things far beyond the capabilities of existing machine learning technology. Today's best algorithms are a long way from being able to really understand all the nuances of natural language. These two paragraphs completely wrap up both the promise and the problem with assistants. As users, we ! The user immediately goes to superuser mode with conversational assistants -whether chat or voice-based and ask them to solve all kinds of problems out of the scope of what’s currently possible. Inevitably, the user then and claims “this is stupid”. so want them to work curses the assistant when it fails I remember the feeling the first few times I tried to get a or . You gotta look past a lot of fail to see the future. modem to connect to the internet using my first cell phone So while the Pangea “all things for everyone” assistant phase ends, I believe we will move to a “continental drift” phase of assistants where smaller assistants will breakout and tackle complex domain-specific problems successfully for end users. There are already quite a and that are effectively solving problems for customers. As more companies have their assistants focus on domain-specific or single purpose assistants we will see more consumers asking “why can’t I do that for (X problem)?” in their lives. Once this happens, I really believe every website, app, device and brand had better be conversational — or start the slow fade to oblivion. few productivity work-related chatbots A lot of these predictions came from the work we are doing at . Our first two beta products, and , are popular voice apps on both Alexa and Google. Our apps are built to work across voice and text platforms, so they also work on FB Messenger and Slack. Our apps are also “multimodal”, which means you can use them with a screen when it’s easier than talking to them. You can see a video of . If you would like your own cross-platform, multimodal assistant for your business, please . Pylon ai Tasted The Bartender how that works here email me And… if you made it this far, we owe you some schwag or a Google Mini! If you’re interested, ! Or if stuff is not your thing, please sign up for our newsletter for updates on conversational assistants, Elixir, React and other stuff we talk about at Pylon. Thanks! send us your address here

It’s Not A Two Horse Race For Voice Assistants And Chatbots Ain’t Dying

This article is excerpted from Chapter 2 of: Functional Programming in C# In this article, I’ll use a simple example that illustrates why should be your weapon of choice when writing code for parallel and, more generally, concurrent execution. pure functions are functions that have no side effects (such as changing state or doing I/O), and whose output is strictly determined by their input arguments. Pure functions Here is our simple scenario: you’d like to format a list of strings as a numbered list; the casing should be standardized, and each item preceded with a counter. To do this, we want to create a ListFormatter class that can be used as follows: var shoppingList = new List<string>{ “coffee beans”, “BANANAS”, “Dates” }; new ListFormatter().Format(shoppingList).ForEach(WriteLine); // prints: 1. Coffee beans// 2. Bananas// 3. Dates Ok, so that’s our requirement. Now, let’s look at a possible implementation for ListFormatter: Listing 1 A list formatter combining pure and impure functions static class StringExt{public static string ToSentenceCase(this string s) (1)=> s.ToUpper()[0] + s.ToLower().Substring(1);} class ListFormatter{int counter; string PrependCounter(string s) => $"{++counter}. {s}"; (2) public List<string> Format(List<string> list)=> list.Select(StringExt.ToSentenceCase) (3).Select(PrependCounter)           (3).ToList();} A pure function An impure function, since it mutates global state Pure and impure functions are applied similarly There are a few things to point out with respect to purity: is pure (its output is strictly determined by the input). Since its computation only depends on the input parameter, it can be made static without any problems. ToSentenceCase increments the counter, so it’s impure. Since it depends on an instance member — the counter — we cannot make it static. PrependCounter In the method, we apply both functions to items in the list with , irrespective of purity. This is something that may well change in future programming languages. Format Select If the list was big enough, would it make sense to perform the string manipulations in parallel? Could the runtime decide to do this, as an optimization? We’ll tackle these questions next. Pure functions parallelize well Given a big enough set of data to process, it’s usually advantageous to process it in parallel, especially when the processing is CPU­intensive and the pieces of data can be processed independently. The problem is that pure and impure functions do not parallelize equally well, and I’ll illustrate this by trying to parallelize our list formatting functionswith our ListFormatter. , and more generally are immune to the issues that make concurrency difficult. Pure functions parallelize well Compare the expressions: list.Select(ToSentenceCase).ToList()list.AsParallel().Select(ToSentenceCase).ToList() In the first, we’re using the method defined on to apply the the pure function to each element in the list. The second expression is very similar, but we use methods provided by Parallel LINQ (PLINQ). Select Enumerale ToSentenceCase turns the list into a . As a result, resolves to the implementation defined on , which will apply to each item in the list, but now in parallel (that is, the list will be split into chunks, and then several threads will be fired off to process each chunk). In both cases, we’re then using to harvest the results into a list. AsParallel ParallelQuery Select ParallelEnumerable ToSentenceCase ToList As you would expect, the two expressions yield the same result, but one does so synchronously and the other in parallel. This is nice: just one call to and we get parallelization almost for free. AsParallel But this raises the questions: Why “almost” for free? Why can’t we have it for free? In other words, why do we have to explicitly instruct the runtime to parallelize the operation? Why can’t it just figure out that it’s a good idea to parallelize the operation, just like it figures out when it’s a good time to run the garbage collector? The answer is that the runtime doesn’t know enough about the function being applied, to make an informed decision of whether parallelization may change the program flow. Because of their properties, pure functions can always be applied in parallel, but as we pointed out, the runtime does not know about the purity of the function being applied, and this is why I expect future languages to be different in this respect. Parallelizing impure functions Let’s see what happens if we naively apply parallelization with the impure function: PrependCounter list.Select(PrependCounter).ToList()list.AsParallel().Select(PrependCounter).ToList() Since increments the counter variable, in the parallel version we will have multiple threads reading and updating the counter concurrently. As is well known, is not an atomic operation, and since there is no locking in place we will lose some of the updates, and end up with an incorrect result. PrependCounter ++ If you test this approach with a big enough input you will get an error along the lines of: Expected string length 20 but was 19. Strings differ at index 0.Expected: "1000000. Item1000000"But was:  "956883. Item1000000"-----------^ This sould all sound pretty familiar if you have some multithreading experience. Because multiple processes are reading and writing to the counter at the same time, some of the updates are lost. You probably know that this could be fixed by using a lock or the Interlocked class when incrementing the counter. But locking is an imperative construct that we would rather avoid when coding functionally. Let’s summarize what we learned from the above. Unlike pure functions, whose application can be parallelized by default, impure functions don’t parallelize out of the box. And, since parallel execution is non­deterministic, you may get some cases in which your result is correct, and others in which it isn’t (not the sort of bug we like to face). . Furthermore, if you develop with purity in mind, it will be easier to parallelize execution, if you decide to do so. Being aware of whether your functions are pure may help you understand and prevent these issues Avoiding state mutation Instead of locking, another way to avoid the pitfalls of concurrent updates is to remove the problem at the source; that is, don’t use shared state to begin with! How this is done naturally varies for each scenario, but I’ll show a solution to the current scenario, that enables us to format the list in parallel. Let’s go back to the drawing board and see if we can have a non­parallel solution that does not involve mutation. What if, instead of updating a running counter, we generate a list of all the counter values we need, and then “pair” items from the list with item from the list of counters? For the list of integers, we can use , a convenience method on . Range Enumerable Listing 2 Generating a range of integers Enumerable.Range(1, 3)// => [1, 2, 3] The operation of “pairing” two parallel lists is a common operation in FP, and it’s called . For example: Zip Listing 3 Combining elements from parallel lists with Zip Enumerable.Zip(new[] {1, 2, 3},new[] {"ichi", "ni", "san"},(number, name) => $"In Japanese, {number} is: {name}") // => ["In Japanese, 1 is: ichi",//     "In Japanese, 2 is: ni",//     "In Japanese, 3 is: san"] Using Range and Zip, we can rewrite our list formatter as follows: Listing 4 List formatter refactored to use pure functions only using static Enumerable; static class ListFormatter{public static List<string> Format(List<string> list){var left = list.Select(StringExt.ToSentenceCase);var right = Range(1, list.Count);var zipped = Zip(left, right, (s, i) => $"{i}. {s}");return zipped.ToList();}} Here, we use the list, with ToSentenceCase applied to it, as the “left side” of . The “right side” is constructed with . The 3rd argument to is the “pairing function”: what we will do with each pair of items. Zip Range Zip can be used as an extension method, so we would usually write the method using a more fluent syntax: Zip Format public static List<string> Format(List<string> list)=> list.Select(StringExt.ToSentenceCase).Zip(Range(1, list.Count), (s, i) => $"{i}. {s}").ToList(); After this refactoring, is pure and can safely be made static. What about making it parallel? Well, now it’s a piece of cake, because PLINQ offers an implementation of that works with parallel queries. A parallel implementation of the list formatter would then look like this: Format Zip Listing 5: A pure implementation that executes in parallel using static ParallelEnumerable; (2) static class ListFormatter{public static List<string> Format(List<string> list)=> list.AsParallel() (1).Select(StringExt.ToSentenceCase).Zip(Range(1, list.Count), (s, i) => $"{i}. {s}").ToList();} Turn the original data source into a parallel query Use the exposed by Range ParallelEnumerable This is almost identical to the non­parallel version: there are only two differences. First, we turn the input list into a , so that everything after is done in parallel. Second, we changed the , with the effect that we will call the method defined on (this returns a , which is what the parallel version of expects). The rest is just as in the non­parallel version, and the parallel version of is stil a pure function. ParallelQuery using static Range ParallelEnumerable ParallelQuery Zip Format In this case, does all the heavy lifting for us, and we were able to easily resolve the problem by reducing our specific scenario to the more common scenario of zipping two parallel sequences — a scenario common enough that it’s addressed in the framework. ParallelEnumerable While in this scenario we enabled parallel execution by removing state updates altogether, doing so will not always be this easy. But hopefully the ideas shown will put you in a better position when tackling issues related to parallelism, and more generally concurrency. For more information (and a discount code!) on Functional Programming in C# download the free or see this . first chapter slideshare presentation _Functional programming is a way of thinking about programs that emphasizes functions, while avoiding state mutation. It…_www.manning.com Manning | Functional Programming in C#

SHOPPINPAL

shoppinpal.com

-- employees

Since n.d.

COMPANY RANKING

SHOPPINPAL

EVERGREEN INDEX #9317

Representing this company? Click here to claim and customize this page!

ShoppinPal WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!

SHOPPINPAL

shoppinpal.com

-- employees

Since n.d.

COMPANY RANKING

SHOPPINPAL

EVERGREEN INDEX #9317

RELATED COMPANIESRANK

STORIES ABOUT SHOPPINPAL

Representing this company? Click here to claim and customize this page!

ShoppinPal WIKI

Apply to get your Tech Company News Page live on HackerNoon.com today!