OpenStore

openstore

Before delving into the details, let me set the stage by using a universally relatable example. I will discuss the concepts of transparency through the lens of employee hiring processes—a scenario familiar to many, whether they work in startups or big corporations. This context will illustrate how transparency impacts a common business operation and why it's crucial for organizational success. Imagine a complex machine encased in a black box: Inputs come in;
something mysterious happens inside;
and outputs emerge, yet the internal operations remain obscured from user's view. This metaphor aptly describes certain business processes which you could find almost in every small or big company. This article will try to throw light on why transparency in processes is indeed important for the users, stakeholders, and other parties. Increased transparency will be a change imperative that is much needed to bring positive change throughout the business environment, helping to make informed decisions faster, waste fewer resources on non-critical activities and focus on main goals we want to achieve. More importantly, transparency truly builds trust—one of the foundations of human relationships defining the success of any business. The Benefits of Shifting to Transparency Transforming the black box of traditional processes into a transparent container revolutionizes how we view and manage operations from start to finish. By making every step from application entry to the final hiring decision visible and comprehensible, not only is the internal team enlightened, but candidates also benefit from a vastly improved experience. This visibility throughout the journey underscores the value of openness and clarity. Fostering Trust Through Openness Transparency naturally cultivates trust. It clarifies the mechanisms and criteria used in decision-making both for the team and for applicants, ensuring that all parties are well-informed. This openness is crucial for building assurance, respect, and mutual confidence, transforming the workplace into an environment where everyone feels valued and understood. Optimizing Streamlining Through Visibility When once-opaque processes become crystal clear, it’s easier to identify and address choke points and redundancies. This visibility facilitates smoother decision-making and optimizes every step of the process. Moreover, such transparency can spur innovation and efficiency by democratizing the search for solutions. When everyone can see and understand the workflow, innovative ideas and improvements can emerge from any level within the organization. Enabling Automation and Liberating Creativity With a transparent system, automation of routine tasks becomes a practical solution, allowing the workforce to focus their creativity where it truly matters. This shift not only boosts productivity but also enhances job satisfaction by freeing up personnel to tackle more complex and rewarding challenges. Thus, transparency not only streamlines operations but also enriches the workplace by empowering employees to contribute to meaningful changes and innovations. The Black Box Of The Hiring Process Imagine some hiring processes that hinge on a six-person circle around a spreadsheet; doggedly adhering to the old way of doing things because 'that's how it's always been done. Slow, opaque, and rarely subject to critical introspection except for finding it increasingly under the demand to scale rapidly. Through this labyrinthine process, CVs continually come in and out of the system, and in some obscure and arcane way, a new hire eventually emerges. But the real quality of the hire, reasons for the delays, and the costs remain obscure”cloaked by the walls of a black box, figuratively speaking. Such a system stifles efficiency by making it unavailable to the organization to get critical insights needed to properly improve and adapt its hiring practices. Steps Toward Unveiling Process Transparency Build or ReBuild proper process using IT tools At least, you need to build an IT system to make such a transparent process. Since it may store all your data that you would like and need to save for future analysis, then it can give a great report whereby the process could improve or building some business metric to show them in the business, and many more. For example, for our considered HR process, you could establish some automation where it is possible, wherever you need the actions of humans; you could fit all the necessary actions into some interface and save all the data about the operational work of an HR team, about candidates, etc. You're going to use all this data. You can easily create such a system for the processes with low-code tools. I previously wrote about exact example how it could be used in this article. https://hackernoon.com/using-low-code-development-to-streamline-internal-business-processes?embedable=true Creating a Transparent Culture Adopting a culture of transparency represents a fundamental shift from opacity to clarity, where the mechanisms of processes are openly discussed. This cultural transformation encourages healthy feedback and welcomes change, fostering an environment where all team members feel comfortable voicing their ideas and concerns. Such openness not only promotes a deeper understanding of processes but also helps in refining them continuously. Defining, Measuring, and Refining Processes To establish a truly transparent system it's crucial to define each step of a process with precision and clarity. Outline the criteria for success distinctly so that everyone understands what achievements look like. This approach doesn't just clarify the existing processes; it provides a structured method for ongoing improvement. By setting clear benchmarks and regularly reviewing outcomes, the organization can continuously evolve, becoming more efficient and effective over time. Educating and Empowering the Team Education and empowerment are key to maintaining transparency within the organization. Equip your team with the necessary tools and knowledge through targeted training sessions on new technologies and processes. Conduct workshops to demonstrate the tangible benefits of transparency and encourage an open dialogue about these new methods. By creating an environment that supports continuous learning and growth, you ensure that every team member not only understands the value of transparency but is also skilled in applying it to their work. This commitment to education and empowerment not only enhances individual performance but also drives collective success. Conclusion "Breaking open the black box" means transforming secretive, complex business processes into something clear and understandable. For example, in hiring, this means making every step of the process clear and justifiable. By doing this, we make hiring more straightforward and set an example for transparency that can be followed in all parts of the organization. This change does more than just make things simpler; it also helps everyone understand what’s happening inside the company. By being open about how things work, we build a workplace that values trust, clarity, and innovation. This approach sheds light on current practices and also paves the way for ongoing improvements and new ideas. Before delving into the details, let me set the stage by using a universally relatable example. I will discuss the concepts of transparency through the lens of employee hiring processes—a scenario familiar to many, whether they work in startups or big corporations. This context will illustrate how transparency impacts a common business operation and why it's crucial for organizational success. Imagine a complex machine encased in a black box: Inputs come in; something mysterious happens inside; and outputs emerge, yet the internal operations remain obscured from user's view. Inputs come in; something mysterious happens inside; and outputs emerge, yet the internal operations remain obscured from user's view. This metaphor aptly describes certain business processes which you could find almost in every small or big company. This article will try to throw light on why transparency in processes is indeed important for the users, stakeholders, and other parties. Increased transparency will be a change imperative that is much needed to bring positive change throughout the business environment, helping to make informed decisions faster, waste fewer resources on non-critical activities and focus on main goals we want to achieve. More importantly, transparency truly builds trust—one of the foundations of human relationships defining the success of any business. The Benefits of Shifting to Transparency Transforming the black box of traditional processes into a transparent container revolutionizes how we view and manage operations from start to finish. By making every step from application entry to the final hiring decision visible and comprehensible, not only is the internal team enlightened, but candidates also benefit from a vastly improved experience. This visibility throughout the journey underscores the value of openness and clarity. Fostering Trust Through Openness Transparency naturally cultivates trust. It clarifies the mechanisms and criteria used in decision-making both for the team and for applicants, ensuring that all parties are well-informed. This openness is crucial for building assurance, respect, and mutual confidence, transforming the workplace into an environment where everyone feels valued and understood. Optimizing Streamlining Through Visibility When once-opaque processes become crystal clear, it’s easier to identify and address choke points and redundancies. This visibility facilitates smoother decision-making and optimizes every step of the process. Moreover, such transparency can spur innovation and efficiency by democratizing the search for solutions. When everyone can see and understand the workflow, innovative ideas and improvements can emerge from any level within the organization. Enabling Automation and Liberating Creativity With a transparent system, automation of routine tasks becomes a practical solution, allowing the workforce to focus their creativity where it truly matters. This shift not only boosts productivity but also enhances job satisfaction by freeing up personnel to tackle more complex and rewarding challenges. Thus, transparency not only streamlines operations but also enriches the workplace by empowering employees to contribute to meaningful changes and innovations. The Black Box Of The Hiring Process Imagine some hiring processes that hinge on a six-person circle around a spreadsheet; doggedly adhering to the old way of doing things because 'that's how it's always been done. Slow, opaque, and rarely subject to critical introspection except for finding it increasingly under the demand to scale rapidly. Through this labyrinthine process, CVs continually come in and out of the system, and in some obscure and arcane way, a new hire eventually emerges. But the real quality of the hire, reasons for the delays, and the costs remain obscure”cloaked by the walls of a black box, figuratively speaking. Such a system stifles efficiency by making it unavailable to the organization to get critical insights needed to properly improve and adapt its hiring practices. Steps Toward Unveiling Process Transparency Steps Toward Unveiling Process Transparency Build or ReBuild proper process using IT tools At least, you need to build an IT system to make such a transparent process. Since it may store all your data that you would like and need to save for future analysis, then it can give a great report whereby the process could improve or building some business metric to show them in the business, and many more. For example, for our considered HR process, you could establish some automation where it is possible, wherever you need the actions of humans; you could fit all the necessary actions into some interface and save all the data about the operational work of an HR team, about candidates, etc. You're going to use all this data. You can easily create such a system for the processes with low-code tools. I previously wrote about exact example how it could be used in this article. article . article https://hackernoon.com/using-low-code-development-to-streamline-internal-business-processes?embedable=true https://hackernoon.com/using-low-code-development-to-streamline-internal-business-processes?embedable=true Creating a Transparent Culture Adopting a culture of transparency represents a fundamental shift from opacity to clarity, where the mechanisms of processes are openly discussed. This cultural transformation encourages healthy feedback and welcomes change, fostering an environment where all team members feel comfortable voicing their ideas and concerns. Such openness not only promotes a deeper understanding of processes but also helps in refining them continuously. Defining, Measuring, and Refining Processes To establish a truly transparent system it's crucial to define each step of a process with precision and clarity. Outline the criteria for success distinctly so that everyone understands what achievements look like. This approach doesn't just clarify the existing processes; it provides a structured method for ongoing improvement. By setting clear benchmarks and regularly reviewing outcomes, the organization can continuously evolve, becoming more efficient and effective over time. Educating and Empowering the Team Education and empowerment are key to maintaining transparency within the organization. Equip your team with the necessary tools and knowledge through targeted training sessions on new technologies and processes. Conduct workshops to demonstrate the tangible benefits of transparency and encourage an open dialogue about these new methods. By creating an environment that supports continuous learning and growth, you ensure that every team member not only understands the value of transparency but is also skilled in applying it to their work. This commitment to education and empowerment not only enhances individual performance but also drives collective success. Conclusion "Breaking open the black box" means transforming secretive, complex business processes into something clear and understandable. For example, in hiring, this means making every step of the process clear and justifiable. By doing this, we make hiring more straightforward and set an example for transparency that can be followed in all parts of the organization. This change does more than just make things simpler; it also helps everyone understand what’s happening inside the company. By being open about how things work, we build a workplace that values trust, clarity, and innovation. This approach sheds light on current practices and also paves the way for ongoing improvements and new ideas.

The Trust and Efficiency Catalyst

👋 I’m , a product builder. I’ve built multiple apps using the method: , , , , , , +more Zoe Chew rapid MVP sneaker app personal FAQ meal kit app virtual event app SaaS tracker food delivery content app At , I’m on a quest to understand the . I analyze profitable industries & biggest players, and how you can compete and monetize—at the intersection of Internet platforms & consumer tech. Venturescale future of the Internet Today’s post is about . Read here if you’re interested in the , , , or e-commerce acquisition platforms Web3 creators economy future of social networks FinTech & wellness tech B2C online marketplaces . The Rise of e-commerce Roll-ups In the past, roll-ups were mainly proceeded by private equity firms, large conglomerates, and institutional buyers, whereby companies in the same market and merging them under a single entity to scale. acquire businesses Today, there are new companies that consolidate independent private label brands with decent revenue. They are the . Unlike marketplaces that connect buyers and sellers to acquire or sell off their brands (e.g., and by Shopify), roll-up platforms are operational and resourceful. They: aggregators of e-commerce brands Flippa Exchange Marketplace Have a thesis around e-commerce product categories they want to acquire Search across marketplaces like Amazon and Shopify Find winners and merge these companies Operate like a private equity firm, may fund and invest in buyout businesses Platform-agnostic or vertical-focused Grow them collectively using built-in technology, infrastructure, data analytics, operational expertise, capital, and economies of scale 3 more specific strategies on how aggregators operate and scale (📥 Full version) Key Players Around the World (made in profits, acquired more than 100+ brands), , , and Amazon-focused aggregators: Thrasio $100 million Heyday Perch Branded Shopify aggregator: OpenStore Home living & consumer electronics roll-up: Berlin Brands Group (raised ) targets acquisition on Tokopedia, Lazada, Shopee, and Rakuten using a approach by focusing on Shopify, Magento, or WooCommerce. Asia-Pacific focused consolidator: Una Brands US$40 million platform-agnostic 1 more company that focuses on the Amazon platform (📥 Full version) 5 more companies from emerging market (📥 Full version) What Problems Do They Solve? Roll-up platforms help successful e-commerce merchants or direct-to-consumer (D2C) brands to exit their businesses lucratively. Not being able to find ideal buyers ➝ help sellers get acquired. 3 more valid problems they are solving that actually make these platforms super profitable. You’ll also learn: (📥 Full version) How do roll-up platforms create values for their clients? What are the user pain points in getting a business acquired? How do they tackle complexities in selling off businesses? Business Models Roll-up companies are running the business using a private-equity model. They act like collaborators, operators, and venture capitalists (VC) at the same time. For example: acquires third-party sellers on Amazon, focusing on everyday consumer brands, scale the business, and offer exit options for the sellers. In 2020, Thrasio recorded a profit of on $500 million in revenues. Thrasio $100 million provides tech stack, capital, advice, and insights to help consumer product brands accelerate the next level of growth. Heyday 2 more specific ways to monetize as e-commerce aggregators. You’ll also learn: (📥 Full version) different ways to partner with potential acquisition targets different ways to expand your roll-up portfolio Why Now? As e-commerce entrepreneurship is exploding, there will be more successful independent merchants who will need to find a way to exit their brands. Here is the market potential snapshot: In 2020, more than of Amazon’s gross merchandise volume (GMV) was coming from third-party, independent sellers. Growing numbers of independent sellers. 50% 3 more market evidence in detail to help you answer the “why now” questions for your investors or partners. You’ll also learn: (📥 Full version) insight from Amazon financial statement impact of D2C brands insight from the emerging e-commerce markets and why there are untapped opportunities to monetize Business Opportunities 4 specific product ideas and business opportunities that are solving problems. You’ll unlock: (📥 Full version) one specific product idea in SaaS one vertical-focused roll-up platform idea a solution to help aggregators find the next acquisition winner specific business idea to participate in a roll-up partnership Want more? Consider the members-only  version: 🔺 3 more on how aggregators operate and scale specific strategies 📝 6 more new market players 🧐 3 more they are solving that actually make these platforms super- profitable valid problems 🖍 3 more in detail to help you answer the “why now” questions (most important slide in a pitch deck!) for your investors market evidence 🚀 4 and business opportunities that are solving problems specific product ideas [1] Find me on Personal Site / Twitter / LinkedIn 🔥 [2] Weekly market insights in your inbox — Click here to join my newsletter 💌 👉 Get the full report here This article is part of my ↗️ where I share insights on building things in tech. Join me :)‍ Note: resource newsletters Also Published At: https://whizzoe.substack.com/p/e-commerce-roll-ups-and-the-rise

The Rise of E-commerce Roll-ups & New Business Opportunities

I know building TODO List won't always get you too far😴, but it can teach you basic concepts and implementation of a particular framework. Here is the demo of what we're going to build in this tutorial.👇👇 Link: https://react-redux-todo-app-lac.vercel.app/ Now please, if you're starting this tutorial watch till the end because doing it half won't teach you anything. So let's dig in.🤩 In this tutorial, we're going to build this TODO app with animations using Framer-Motion. What will you learn after this Tutorial? How to use Redux Toolkit How to use Framer-Motion for awesome animations Method to sort and display lists CRUD operation (obviously🤭) If you prefer to code along with the same steps while listing to music you can watch this video 👀: You must have basic understanding of Redux to follow this tutorial, don't worry if you don't know the basics of Redux you can visit my channel, there is playlist to learn redux. Let's Get Started First, below is the folder structure for this small project so make sure you create it. Folder Structure |--redux(folder)
   |--reducer.js (here we will create actions and reducer)
   |--store.js
|--components(folder)
   |--Todos.js
   |--TodoItem.js
    --DisplayTodos.js
|--css(folder)
   |--main.css src Follow the below commands to create the react-app and install the required libraries! cd your-app-name
npm install react-redux @reduxjs/toolkit framer-motion react-icons npx create-react-app your-app-name We're going to use all four libraries; react-icons is to add svg files in our app. First, let's add one input and add a button in the . Todos.js setTodo(e.target.value);
  }; );
}; import React, { useState } from "react" ; const Todos = ( props ) => { const [todo, setTodo] = useState( "" ); const handleChange = ( e ) => { return ( < div className = "addTodos" > < input type = "text" onChange = {(e) => handleChange(e)} className="todo-input" value={todo} /> < button className = "add-btn" > Add </ button > < br /> </ div > export default Todos; As you can see in the above code it has one input with handleChange() method and one add button. Creating Reducer and Store Now, let's create our Reducer and actions. Open file and write the below code: reducer.js initialState, state.push(action.payload); },
   
  },
  
}); import { createSlice } from "@reduxjs/toolkit" ; const initialState = []; const addTodoReducer = createSlice({ name : "todos" , reducers : { //here we will write our reducer //Adding todos addTodos : ( state, action ) => { return state; export const { addTodos } = addTodoReducer.actions; export const reducer = addTodoReducer.reducer; Explanation: Now here we're going to use function. createSlice() This function takes 1 object having 3 parameters, --> name of the slice function --> initial State --> All reducer logic inside reducers {} object import createSlice function. Line 1: create initial state here it is an empty array. Line 2: Here we have used createSlice function and passed all 3 required parameters. Line 3: I have created one action called This action gets a callback function that has two arguments (state, action). Then, this function will return state with adding action.payload (payload contains one todo item). addTodos. Here we have exported addTodos as action from addTodoReducer. and we have exported reducer from addTodoReducer. Last two lines: So, let's create our store and pass this reducer. Open store.js and write the below code: }); import { configureStore } from "@reduxjs/toolkit" ; import { reducer } from "./reducer" ; const store = configureStore({ reducer : reducer, export default store; In the above code, we have used the function. configureStore This function takes one reducer and automatically takes care of the Redux DevTools extension so we don't have to write about it explicitly. Now, our store is ready with the reducer that we have created. Connecting Redux Store with React App Let's connect this store to our React application. I like to connect the store in the index.js file. Open index.js file. Import the from the and store from store.js. Provider react-redux import { Provider } from "react-redux" ; import store from "./redux/store" ; Now, just wrap your component with this Provider and pass store in the Provider just like this: <App/> ); ReactDOM.render( < React.StrictMode > //Just like below 👇 < Provider store = {store} > < App /> </ Provider > </ React.StrictMode > , document .getElementById( "root" ) Now, our Redux store is connected with our React App. Connect React component with Redux Let's use this store and Redux functionalities in the component. Todos.js To connect this component with Redux we will use method from . connect() react-redux Open file. Todos.js Import connect method from react-redux. import { connect } from "react-redux" ; Now, instead of simple `export default Todos` change it to this line: export default connect( null , null )(Todos); This is how we use connect method. It's like the higher-order function that takes your component (Todos in our case) and adds redux functionalities to it then returns it. Now, add props in your component and log this props you will see and Object having dispatch method. This means your component is now connected with Redux. Let's use todos state in our component. To use state from redux we have to pass method in the connect method. mapStateToProps and to use actions or functions that we created inside the reducer (like addTodos) we have to create and pass method and add it to the connect method. mapDispatchToProps So, let's create both of these methods in the component. Todos.js };
}; const mapStateToProps = ( state ) => { return { todos : state, This method takes the state as an argument and will return the state as we want here I want to state as todos. };
}; const mapDispatchToProps = ( dispatch ) => { return { addTodo : ( obj ) => dispatch(addTodos(obj)), This method takes dispatch as an argument and it can dispatch an action to the reducer. Here, I want to add todos so this method returns and addTodo method. addTodo method dispatch an addTodos action with an obj (which contains todo item, it will acts as action.payload ). Here, make sure to import addTodos action from reducer file. Now, add both of these methods in the connect just like this: export default connect(mapStateToProps,mapDispatchToProps)(Todos); let's connect input and add button with this state and methods. Here I have created add function. First, it will check if the todo state is not empty if it is empty then shows an alert else it will use addTodo method from props. In this method, we will pass todo object which contains , text, boolean which is initially false. Line 23: id todo completed Make sure to connect add() with onClick of a button. Line 50: here I have mapped values from todos state. Line 55: If todos.length > 0 then it will map it and shows all todo items you add. You can also use Redux DevTools Extension to see actions and state. Add All operations in the Reducer Let's add all the required operations in the reducer. removeTodos will filterout items whose id is the same as action.payload. (which means while using this action we will pass id as payload). Line 16: updateTodos is used to change todo text or todo.item. It will check if id is the same as passed in action.payload, then it will return all other properties of the item and change the text of todos with the passed value. Line 20: completeTodos will change the completed boolean value of particular item to true. Line 32: Make sure to export all the required todo actions. Line 46: Now we will use all these actions. Let's separate the display todos component from file. Remove list from it and let's add it in the DisplayTodo item component. Todos.js ul Before creating component, first, let's create component. DisplayTodos.js TodoItem.js So, open file and write the below code. TodoItem.js Don't read this code, First read the explanation. Now as you saw in the demo each todo item contains 3 buttons , , and . and 3 methods connected with these buttons. edit complete delete This contains the import of icons from the react-icons library, we will use these icons in the edit, update and remove buttons. Line 2 & 3: These are the all required items that we have to pass while displaying component. Line 7: TodoItem item --> contains all the data of single todo item updateTodo --> Method to update todo completeTodo --> method to set todo is completed removeTodo --> method to remove todo item Here in the return Inside this element you can see, Line 23: li --> it shows the todo text as the default value. textarea --> after the text area, there are 3 buttons that contain icons for edit, update and remove, these buttons are connected with all required methods. buttons --> after these buttons there is one span element that shows done, and it will display only when item.completed is true. span It is a ref which is connected with . Its value is true. Line 9: textarea here, we have used ref value for the disabled attribute, which means while ref is true until then stays disabled. Line 30: textarea This change Function will enable the and adds focus on it. This function is connected with the *edit* button. Line 11: textarea This function is used to update the value of the todo item. It will take 3 arguments, id, updated value, and event. Then when you press the enter key then it will call the method and pass all required things as object and disable the textarea. It is connected on in the textarea at . Line 16: updateTodo onKeyPress Line 32 This remove button is connected with the remove method. we have to pass id of the item we want to remove in this method. Line 48: Now let's use this component inside the file. DisplayTodos.js open and write the below code. DisplayTodos.js Make sure to import component in the file right after the component. DisplayTodos.js App.js Todos Contains all the required imports. Line 1-9: we have already discussed both of these methods. Both of these methods must be passed in the connect method. One of them is to map state to props while the other method contains all the required methods to dispatch particular actions. Line 12 & 18: This state is for those 3 buttons which are active, completed, and all. It is initialised with "active". Line 28: This div contains all 3 buttons and onClick of these buttons *sort* state gets changed based on the button it's values can be "active", "completed", or "all". Line 31: In this element we're rendering 3 different lists based on conditions like, Line 53: ul Renders active todo items when (item.completed === false) and (sort === "active") --> Renders completed todo items when (item.completed === true) and (sort === "completed") --> Renders all todo items when (sort === "all") --> This contains all the data that we need to pass in the component. Line 61-65: TodoItem Now for the Framer-motion and CSS part you can watch the video or read the code from github repository. (It will be more easier to understand when you watch the video then writing here about css and animations ) Full Code of this Tutorial can be found: https://github.com/codebucks27/React-Redux-Todo-App That's the end of this whole Tutorial. 😄 If you're confused about anything related to this topic, feel free to ask me 😉! Also, if you want to learn the Basics of Redux, then please do visit my channel. Thanks For Reading and Supporting.😄 My YouTube channel: @CodeBucks Follow me on Instagram where I'm sharing lots of useful tools and resources! @code.bucks 😉

A Tutorial for Todo Apps using React, Redux and Framer-Motion

Hello Pythonistas, In this tutorial you're are going to learn out how to track worldwide cases using requests and BeautifulSoup library in Python. Coronavirus : If you're new to I would recommend checking out firstly and then come back to complete this tutorial. Note webscraping A beginner guide to Webscraping Requirements To effectively follow through with this tutorial, you need to have the following libraries installed on your machine with exception of CSV Module which comes with Python standard library. requests BeautfulSoup CSV Installation Just use the pip to install the mentioned dependencies just as shown below; $ pip install requests

$ pip install beautifulsoup4 Let's get started where do scrap the corona cases? As we have stated above we are going to be the number of cases worldwide by scraping the information from the cloud, there many choices of websites to scrap from but in this tutorial, we will with . tracking worldometer Let's figure out the structure of the website Let's firstly understand the structure of the website we are about to scrap, once you open up the website, and then you will see a table similar to what shown below. worldometer scroll down How table is represented in HTML ? The table in HTML is usually represented with a tag whereby indicate and indicates a specific in that low just as shown in the example below; table tr row td column Row 1, Column 1 Row 1, Column 2 Row 2, Column 1 Row 2, Column 2 < = > table border "1" < > tr < > td </ > td < > td </ > td </ > tr < > tr < > td </ > td < > td </ > td </ > tr </ > table That means every row in the table is represented by tag , therefore we need to filter all rows from table then store in CSV file. worldometers tr the worldometers Complete Coronavirus Spider Below is the complete code of the spider that you're going to build in this tutorial which is capable of scraping the live Coronavirus number from website and then store them in a CSV file. worldometer app.py ​ csv requests bs4 BeautifulSoup

html = requests.get( ).text
html_soup = BeautifulSoup(html, )
rows = html_soup.find_all( ) element = BeautifulSoup(row, ).find_all(tag)
    text = [col.get_text() col element] text

heading = rows.pop( )
heading_row = extract_text(str(heading), )[ : ] open( , ) store:
    Store = csv.writer(store, delimiter= )
    Store.writerow(heading_row) row rows:
        test_data = extract_text(str(row), )[ : ]
        Store.writerow(test_data) import import from import 'https://www.worldometers.info/coronavirus/' 'html.parser' 'tr' : def extract_text (row, tag) 'html.parser' for in return 0 'th' 1 9 with 'corona.csv' 'w' as ',' for in 'td' 1 9 OUTPUT Let's break the code into pieces so as we can understand the role of each part and how they all work together in getting realtime updated numbers. Importing necessary libraries The first 3 lines of code just import all our necessary modules and libraries that we will be using to scrap the live covid19 cases and storing data in the file. csv requests bs4 BeautifulSou import import from import Getting the web-page In order for us to extract and filter coronavirus numbers, we need a way to programmatically access the source code of the webpage, in doing this we will use the requests library just as shown below. html = requests.get( ).text 'https://www.worldometers.info/coronavirus/' Extracting all rows in a table Now that we have the HTML source code of the website, it's now time to parse all the rows present in that table showing coronavirus stats, in doing this will use beautifulSoup just as shown below. html_soup = BeautifulSoup(html, )

rows = html_soup.find_all( ) 'html.parser' 'tr' Making a function do unpack the row columns After extracting all the rows in the table, we need a way to parse all the details on n that row, and that's what the below function does. coronavirus each column i element = BeautifulSoup(row, ).find_all(tag)
    text = [col.get_text() col element] text : def extract_text (row, tag) 'html.parser' for in return Parsing the header Since we don't wanna confuse the header naming and real stats, we need to out the header from the row list as shown below. pop heading = rows.pop( )

heading_row = extract_text(str(heading), )[ : ] 0 'th' 1 9 Parsing row details and storing to CSV Now finally our last job is to parse all the individual details of every row in the table and then store in the file using the module as shown below; CSV CSV Congratulations you have just made your own How to track Coronavirus in Python, to share it with your fellow developers. Tweet now Based on your interest, you might also love these articles; A beginner guide to web scraping How to track phone number in Python The basics of requests module in Python How to extract all website links in Python How to control your Arduino with python How to remove duplicates on your drive using python In case of any comment, suggestion, or difficulties drop it in the comment box below and I will get back to you ASAP. To get the full code for this article you can check out on My Github Previously published at https://kalebujordan.com/scrap-worldometers-live-update-with-beautifulsoup/

How to Track Pandemic Cases With Python

The Object-Oriented Design Principles are the core of OOP programming, but I have seen most of the Java programmers chasing design patterns like , , or , and not putting enough attention on learning . Singleton pattern Decorator pattern Observer pattern Object-oriented analysis and design It’s important to learn the basics of Object-oriented programming like , , , and . But, at the same time, it’s equally important to know object-oriented design principles. Abstraction Encapsulation Polymorphism Inheritance They will help you to create a clean and modular design, which would be easy to test, debug, and maintain in the future. I have regularly seen Java programmers and developers of various experience level, who have either never heard about these and or simply doesn’t know what benefits a particular design principle offers and how to apply these design principle in coding. OOP SOLID design principle , To do my part, I have jotted down all important object-oriented design principles and putting it here for quick reference. These will at least give you some idea about what they are and what benefit they offer. I have not put examples, just to keep the article short but you can find a lot of examples of these design principles on the internet and even on my , just use the search bar at the top of the page. Java blog If you are not able to understand a design principle, you should try to do more than one example because sometimes we connect to another example or author better but you must understand these design principles and learn how to use it in your code. Another thing you can do is to join a comprehensive object-oriented design course like by Steve Smith on Pluralsight. It has helped me a lot in my understanding and application of these principles. SOLID Principles of Object-Oriented Design Btw, I have shared some relevant and useful courses and books here and there, both free and paid, and I will earn some money if you buy something which is not free. They are also some of the resources I have used to learn SOLID design principles and Programming in general and nice for learning some of these principles in depth. 10 Object Oriented and SOLID Desing Principles for Programmers Though the best way of learning any design principle or pattern is a real-world example and understanding the consequences of violating that design principle, subject of this article is Introducing for Java Programmers, who are either not exposed to it or in the learning phase. Object-oriented design principles I personally think each of these and needs an article to explain them clearly, and I will definitely try to do that here, but for now, just get yourself ready for a quick bike ride on design principle town :) OOP SOLID design principles 1. DRY (Don’t repeat yourself) Our first object-oriented design principle is DRY, as the name suggests means don’t write duplicate code, instead use to abstract common things in one place. DRY (don’t repeat yourself) Abstraction If you have a block of code in more than two places consider making it a separate method, or if you use a hard-coded value more than one time make them . The benefit of this Object oriented design principle is in . public final constant maintenance It’s important not to abuse it, duplication is not for code, but for functionality. It means if you have used common code to validate OrderId and SSN it doesn’t mean they are the same or they will remain the same in future. By using common code for two different functionality or thing you closely couple them forever and when your OrderId changes its format, your SSN validation code will break. So beware of such coupling and just don’t combine anything which uses the similar code but are not related. You can further check out the in Java course on Udemy to learn more about writing good code and best practices to follow while designing a system. Basics of Software Architecture & Design Patterns 2. Encapsulate What Changes There is only one thing which is constant in the software field and that is “Change”, So, encapsulate the code you expect or suspect to be changed in future. The benefit of this OOP Design principle is that It’s easy to test and maintain proper encapsulated code. If you are coding in Java then follow the principle of by default and increasing access step by step like from a private to and not . making variable and methods private protected public Several of the uses Encapsulation, the is one example of Encapsulation which encapsulates object creation code and provides flexibility to introduce a new product later with no impact on existing code. design patterns in Java Factory design pattern Btw, if you are interested in learning more about design patterns in Java and Object Oriented Programming then you must check this course Pluralsight. It’s one of the best collection of design patterns and advice on how to use them in the real world. Design Pattern Library 3. Open Closed Design Principle According to tho this OOP design principle, “Classes, methods or functions should be Open for extension (new functionality) and Closed for modification”. This is another beautiful SOLID design principle, coined by Uncle Bob on his classic book, which prevents someone from changing already tried and tested code. Clean Code The key benefit of this design principle is that already tried and tested code is not touched which means they won’t break. Here is a Java code example which the Open Closed Design Principle of Programming: violates In this code GraphicEditor is tightly coupled with Shape, If you need a new Shape then you need to modify already tried and tested code inside thedrawShape(Shape s) method, which is both error-prone and not desirable. Ideally, if you are adding new functionality only than your code should be tested and that’s the goal of . Open Closed Design principle By the way, the Open-Closed principle is “O” from the SOLID acronym. If you want to learn more about this principle, the course on Udemy is one of the best resources to consult. SOLID Principles of Object-Oriented Design and Architecture 4. Single Responsibility Principle (SRP) Single Responsibility Principle is another SOLID design principle, and represent “S” on the SOLID acronym. As per SRP, there should not be more than one reason for a class to change, or a class should always handle single functionality. The key benefit of this principle is that it reduces coupling between the individual component of the software and Code. For example, If you put more than one functionality in one Class in Java it introduces between two functionality and even if you change one functionality there is a chance you broke coupled functionality, which requires another round of testing to avoid any surprise on the production environment. coupling You can further see course on Udemy to learn about patterns which are based on this principle. From 0 to 1: Design Patterns — 24 That Matter 5. Dependency Injection or Inversion principle Don’t ask for dependency it will be provided to you by the framework. This has been very well implemented in , one of the most popular Java framework for writing real-worth applications. Spring framework The beauty of this is that any class which is injected by DI framework is with the mock object and easier to maintain because object creation code is centralized in the framework and client code is not littered with that. design principle easy to test There are multiple ways to implemented like using bytecode instrumentation which some AOP (Aspect Oriented programming) framework like AspectJ does or by using proxies just like used in Spring. Dependency injection You can further see the course on Udemy to learn more about this useful principle. It also represents “D” on the SOLID acronym. SOLID Principles of Object-Oriented Design and Architecture Here is an example of the code which violates Dependency Inversion Principle or DIP in Java: You can see that AppManager depends upon EventLogWriter which is tightly coupled with the AppManager. If you need to use another way to notify your client like by sending push notifications, SMS, or E-mail, you need to change the AppManager class. This problem can be solved by using the Dependency Inversion Principle where instead of AppManager asking for EventLogWriter, it will be injected or provided to AppManager by the framework. You can further see on Udemy to learn more about the Dependency Inversion Principle and how to solve such problems. Using SOLID Principles to Write Better Code — A Crash Course 6. Favor Composition over Inheritance There are two general ways to reuse the code you have already written, Inheritance and Composition, both have their own advantage and disadvantages, but, in general, you should always favor composition over inheritance, if possible. Some of you may argue this, but I found that is the lot more flexible than . Composition Inheritance Composition allows changing the behavior of a class at run-time by setting property during run-time and by using Interfaces to compose a class we use which provides flexibility to replace with better implementation any time. polymorphism Even Joshua Bloch’s advise favoring composition over inheritance. If you are still not convinced then you can also read to learn more about why your Composition is better than Inheritance for reusing code and functionality. Effective Java here And, if you keep forgetting this rule, here is a nice cartoon to put in your desk :-) If you are interested in learning more about Object Oriented Programming Concepts like Composition, Inheritance, Association, Aggregation, etc, you can also take a look at the course on . Object-Oriented Programming in Java Coursera It’s free to explore and learn but you will be charged if you also want to participate in exercises, assignment, evaluation and need Certification to show in your LinkedIn profile. 7. Liskov Substitution Principle (LSP) According to the Liskov Substitution Principle, Subtypes must be substitutable for supertype I mean methods or functions which uses superclass type must be able to work with the of subclass without any issue”. object LSP is closely related and . to the Single responsibility principle Interface Segregation Principle If a class has more functionality than subclass might not support some of the functionality and does violate LSP. In order to follow , derived class or subclass must enhance functionality, but not reduce them. LSP represents “L” on the SOLID acronym. LSP SOLID design principle Here is a code example which violates the Liskov Substitution Principle in Java: Liskov Substitution Principle in Java If you have a method area(Rectangle r) which calculates the area of Rectangle then that code will break when you pass the Square because Square is not really a Rectangle. If you are interested in a more real-world example, then the course on Pluarlsight is a good course to start with. SOLID Principles of Object-Oriented Design Btw, you would need a Pluralsight membership to get access this course, which cost around $29 per month or $299 annually (14% discount). Even if you don’t have a membership, you can still access this course for FREE by taking advantage of their without any commitment, which is a great way to not just access this course for free but also to check the quality of courses before joining Pluralsight 10-day free trial 8. Interface Segregation Principle (ISP) Interface Segregation Principle stats that, a client should not implement an if it doesn’t use that. interface This happens mostly when one interface contains more than one functionality, and the client only needs one functionality and no other. There is no doubt that Interface design is a tricky job because once you release your interface you can not change it without breaking all implementation. Well, Java 8’s feature does provide a way for interface evolution but not all Programming language support that features. default or defender method Another benefit of this design principle in Java is, the interface has the disadvantage of implementing all method before any class can use it so having single functionality means less method to implement. If you don’t the get the benefit of the interface in coding then I suggest you read my blog post, the to learn more. real usage of an interface in Java 9. Programming for Interface not implementation A programmer should always this will lead to flexible code which can work with any new implementation of the interface. program for the interface and not for implementation In concrete words, you should use interface type on variables, return types of a method or argument type of methods in Java like using SuperClass type to store object rather using SubClass. I mean List numbers= getNumbers(); instead of ArrayList numbers = getNumbers(); This has also been advised in many Java books including in and book. Effective Java Head First design pattern Here is an example of Coding for the interface in Java: If you are interested in improving code quality of your program, I also suggest you take a look at the course on Udemy which will help you to improve the internal design with refactoring techniques and design patterns in C# Refactoring to Design Patterns 10. Delegation principles Don’t do all stuff by yourself, delegate it to the respective class. Classical example of delegation design principle is . equals() and hashCode() method in Java In order to compare two objects for equality, we ask the class itself to do comparison instead of Client class doing that check. The key benefit of this design principle is and pretty easy to modify behavior. Event delegation is another example of this principle, where an event is delegated to handlers for handling. no duplication of code Summary All these help you write flexible and better code by striving high cohesion and low coupling. object-oriented design principles The theory is the first step, but what is most important is to . develop the ability to find out when to apply these design principles Once you get hold of that, the next step is to learn Design patterns in Java, which uses these design patterns to solve common problems of application development and software engineering. If you are looking for a nice course to start with, I suggest you join the course on Udemy. It’s very comprehensive and you can get it in just $11 on their several flash sales. From 0 to 1: Design Patterns — 24 That Matter — In Java Anyway, here is a nice summary of all these OOP design principles. Find out, whether we are violating any design principle and compromising the flexibility of code, but again as nothing is perfect in this world, don’t always try to solve the problem with they are mostly for large enterprise project which has longer maintenance cycle. design patterns and design principle Bottom line is, professionals programmers should always strive for a highly cohesive and loosely couple solution, code or design. Looking open source code from Apache and Google are some good ways of learning and . Java OOP design principles They will show you, how design principles should be used in coding and Java programs. Java Development Kit follows many design principles like in BorderFactory class, in java.lang.Runtime class, on various java.io classes. Factory Pattern Singleton pattern Decorator pattern If you are interested in learning object-oriented principles and patterns, then you can look at my another personal favorite , an excellent book and probably the best material available in object-oriented analysis and design Head First Object-Oriented Analysis and Design Not many programmers know this book because it is often shadowed by its more popular cousin by , which is more about how these principles come together to create a pattern you can use directly to solve known problems. Head First Design Pattern Eric Freeman These books help a lot to write better code, taking full advantage of various Object-oriented and SOLID design principles. Btw, if you really interested more in Java coding practices then read by Joshua Bloch, a gem by the guy who wrote Java Collection API. Effective Java 3rd Edition If you want to learn more about SOLID design Principles, here are some useful resources you can take a look: By Clean Code Robert Martin SOLID Principles of Object-Oriented Design SOLID Principles of Object-Oriented Design and Architecture Refactoring by Martin Fowler And, if you like this article, you may like these : Java and Programming articles as well 10 Things Java Programmer should learn in 2019 10 Books Every Programmer Must Read 10 Tips to Improve Your Programming skill 10 Tools Every Software Developer should know 5 Courses to Learn Software Architecture in Depth 20 Libraries and APIS Java Programmer Should Know Top 10 Programming languages to Learn in 2019 10 Framework and Library Java and Web Developer Should Learn Thanks for reading this article. If you find these object-oriented design principles useful then please share with your friends and colleagues. If you have any questions or feedback then please drop a note. Btw, if you buy any of my recommended book or course, I’ll be also be paid. If you like this article then please consider following me on medium ( ). if you’d like to be notified for every new post and don’t forget to follow on Twitter! javinpaul javarevisited If you are really passionate about your Coding and want to improve your coding skill there are no better books then by and Refactoring by . Just go and read them. P. S. — Clean Code Robert Martin Martin P. Fowler

10 OOP Design Principles Every Programmer Should Know

10 principios de diseño de programación orientada a objetos que todo programador debe conocer

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

Replacing Redux Thunks with Redux Sagas

Statistical NLP on OpenStreetMap: Part 2

A Nationwide Drive Time Matrix Between U.S. ZIP Code Areas: Conclusion, Acknowledgement & References

Authors:
(1) Yujie Hu, Department of Geography, University of Florida, Gainesville, FL 32611 and UF Informatics Institute, University of Florida, Gainesville, FL 32611;
(2) Changzhen Wang, Department of Geography & Anthropology, Louisiana State University, Baton Rouge, LA 70803;
(3) Ruiyang Li, Children’s Environmental Health Initiative, Rice University, Houston, TX 77005;
(4)Fahui Wang, Department of Geography & Anthropology, Louisiana State University, Baton Rouge, LA 70803. Table of Links Abstract and 1 Introduction. Methodology Results Concluding comments, Acknowledgement and References Abstract Estimating a massive drive time matrix between locations is a practical but challenging task. The challenges include availability of reliable road network (including traffic) data, programming expertise, and access to high-performance computing resources. This research proposes a method for estimating a nationwide drive time matrix between ZIP code areas in the U.S.—a geographic unit at which many national datasets such as health information are compiled and distributed. The method (1) does not rely on intensive efforts in data preparation or access to advanced computing resources, (2) uses algorithms of varying complexity and computational time to estimate drive times of different trip lengths, and (3) accounts for both interzonal and intrazonal drive times. The core design samples ZIP code pairs with various intensities according to trip lengths and derives the drive times via Google Maps API, and the Google times are then used to adjust and improve some primitive estimates of drive times with low computational costs. The result provides a valuable resource for researchers. Introduction Estimating a drive time matrix between locations is a critical task in spatial analysis, commonly encountered by researchers in geography, urban planning, transportation engineering, business management, and operational research, etc. To list a few, analytical models such as spatial interaction modeling (Simini et al., 2012), travel demand estimation (McFadden, 1974), location-allocation problems (ReVelle and Swain, 1970; Hu et al., 2019), spatial accessibility measures (Luo and Wang, 2003; Dony et al., 2015; Balomenos et al., 2019; Zhu et al., 2020), and delineation of health care market areas (Wang et al. 2020), rely on attainment of reliable drive time estimation from a set of origin locations to a set of destination locations. Such a task for a small-size matrix has become routine in many GIS and transportation packages, such as ESRI® ArcGIS and Caliper® TransCAD. However, it can be a challenging task for a large matrix. Most studies in this scope focus on small areas like individual cities or counties. Estimating the time matrix at larger geographic scales, such as a national scope, is of increasingly great importance to researchers and policy makers. Take the U.S. health care as an example, a national travel time matrix is the most critical component to study the average geographic access to health care (Onega et al., 2008; Boscoe et al., 2012), measure the variations in geographic access across regions (Onega et al., 2017), identify the areas where the health care geographic access is significantly lower than average, suggest the most appropriate sites for new care facilities, and facilitate the implementation of other strategies for reducing health care disparities such as remote health care, health care on wheels, and transit to care. The challenges for calibrating a large drive time matrix include availability of reliable road network (including traffic) data, programming expertise, and computational power. Many studies assume a free flow condition on roads to eliminate the data requirement on traffic, and are often limited to estimation of drive times from areas (e.g., ZIP code area, census tract) to the nearest locations (Onega et al., 2008; 2017; Boscoe et al., 2012; Ikram et al., 2015) or between locations within a short range (Shi et al., 2012) with a significantly reduced number of OD (origin-destination) pairs. Most recently, Saxon and Snow (2019) estimated a drive time matrix from each census tract to each primary care location within 62 miles (100 km) in the U.S. by tapping into advanced computing resources such as distributed computing and sophisticated algorithms, which may not be accessible by most researchers. They did not consider traffic conditions or node impedance, and the result tended to underestimate drive times especially for short trips. One way to account for traffic effect in drive time estimation relies on the utilization of traffic sensors or auxiliary data sources. These sensors include loop detectors (Kwon et al., 2000; Coifman, 2002) and automatic vehicle identification systems—such as toll collection system (El Faouzi et al., 2009), license plate recognition system (van Hinsbergen et al., 2009), and Bluetooth-based system (Bhaskar and Chung, 2013)—that are installed at certain locations along the road. They can accurately capture travel speeds and times. Other sensors are rather flexible, such as the floating or probe vehicles that consist of a sample of vehicles equipped with GPS units running with traffic (De Fabritiis et al., 2008). Based on collected information on a vehicle’s location, direction, and speed in a short time interval, drive times between any two locations in a network can be readily attained (Semanjski, 2015). A few recent studies attempted to estimate drive times using big data. Toole et al. (2015) used call detail records (CDRs) to obtain drive times for all road segments in five selected cities worldwide. Woodard et al. (2017) derived drive times on all roadways in the Seattle metropolitan region based on collected mobile phone GPS data. Although these methods can provide highly accurate estimates on actual drive times in traffic, their reliance on installation of physical equipment or big crowdsourced data restricts their usage to only small areas ranging from major corridors to metro regions. An alternative approach is to use third-party web mapping services such as Google Maps and MapQuest. For example, Google Maps Distance Matrix API uses the Google data such as its road network and collected traffic information to estimate drive times between a set of origins and a set of destinations. Similarly, MapQuest’s Route Matrix API uses open-source mapping data from the OpenStreetMap project to achieve this goal. Another benefit of using these commercial web services is to relieve analysts of the burden of preparing street network data and accessing GIS/transportation software (Boscoe et al., 2012). However, the free usage of these services comes with request limits. For instance, Google Maps offers free usage up to 40,000 OD records per month (Hu and Downs, 2019). A similar restriction applies to MapQuest. As a result, researchers usually use this approach to derive drive times for a limited number of OD pairs (Wang and Xu, 2011). Another issue related to drive time estimation between areas is the so-called aggregation error (Hu and Wang, 2016). The centroid-to-centroid approach assumes that all people in an area live at the centroid of an area (Hewko et al., 2002), and inevitably overlooks intrazonal travels (Kordi et al., 2012; Bhatta and Larsen, 2011). For example, the average commuting time within a traffic analysis zone (TAZ) is 11.3 minutes for auto drivers in Cleveland, Ohio (Wang, 2003). Given the average area of 82.25 square miles for the ZIP code areas in the U.S., intrazonal drive times at the ZIP code area level can be significant, especially in low-density suburban or rural areas. Its omission accounts for a high percentage in error for short-range trips. A common approach approximates intrazonal travel distance as the radius of an area-equivalent circle (Frost et al., 1998, Horner and Murray, 2002; Hu and Wang, 2015). Some recent studies use Monte Carlo simulation techniques to improve the estimation of trip lengths between area units (Hu and Wang, 2016; Hu et al. 2017), and offers a viable solution to intrazonal drive time estimation. This study seeks to estimate a very large drive time matrix between ZIP code areas in the U.S. ZIP code area is a popular geographic unit used in many nationwide datasets. For instance, ZIP code area is often the finest geographic scale at which health information is compiled and distributed in the U.S. (Berke and Shi, 2009). Our method (1) does not rely on intensive efforts in data preparation or access to advanced computing resources, (2) uses algorithms of varying complexity and computational time to estimate drive times of different trip lengths, and (3) accounts for both interzonal and intrazonal drive times. Both the program and results will be available for free download, and provide a valuable resource for researchers. This paper is available on arxiv under CC BY 4.0 DEED license. [1T] his is a preprint of: Hu, Y., Wang, C., Li, R., & Wang, F. (2020). Estimating a large drive time matrix between ZIP codes in the United States: A differential sampling approach. Journal of Transport Geography, 86, 102770. https://doi.org/10.1016/j.jtrangeo.2020.102770 Authors: (1) Yujie Hu, Department of Geography, University of Florida, Gainesville, FL 32611 and UF Informatics Institute, University of Florida, Gainesville, FL 32611; (2) Changzhen Wang, Department of Geography & Anthropology, Louisiana State University, Baton Rouge, LA 70803; (3) Ruiyang Li, Children’s Environmental Health Initiative, Rice University, Houston, TX 77005; (4)Fahui Wang, Department of Geography & Anthropology, Louisiana State University, Baton Rouge, LA 70803. Authors: Authors: (1) Yujie Hu, Department of Geography, University of Florida, Gainesville, FL 32611 and UF Informatics Institute, University of Florida, Gainesville, FL 32611; (2) Changzhen Wang, Department of Geography & Anthropology, Louisiana State University, Baton Rouge, LA 70803; (3) Ruiyang Li, Children’s Environmental Health Initiative, Rice University, Houston, TX 77005; (4)Fahui Wang, Department of Geography & Anthropology, Louisiana State University, Baton Rouge, LA 70803. Table of Links Abstract and 1 Introduction. Abstract and 1 Introduction. Methodology Methodology Results Results Concluding comments, Acknowledgement and References Concluding comments, Acknowledgement and References Abstract Estimating a massive drive time matrix between locations is a practical but challenging task. The challenges include availability of reliable road network (including traffic) data, programming expertise, and access to high-performance computing resources. This research proposes a method for estimating a nationwide drive time matrix between ZIP code areas in the U.S.—a geographic unit at which many national datasets such as health information are compiled and distributed. The method (1) does not rely on intensive efforts in data preparation or access to advanced computing resources, (2) uses algorithms of varying complexity and computational time to estimate drive times of different trip lengths, and (3) accounts for both interzonal and intrazonal drive times. The core design samples ZIP code pairs with various intensities according to trip lengths and derives the drive times via Google Maps API, and the Google times are then used to adjust and improve some primitive estimates of drive times with low computational costs. The result provides a valuable resource for researchers. Introduction Estimating a drive time matrix between locations is a critical task in spatial analysis, commonly encountered by researchers in geography, urban planning, transportation engineering, business management, and operational research, etc. To list a few, analytical models such as spatial interaction modeling (Simini et al., 2012), travel demand estimation (McFadden, 1974), location-allocation problems (ReVelle and Swain, 1970; Hu et al., 2019), spatial accessibility measures (Luo and Wang, 2003; Dony et al., 2015; Balomenos et al., 2019; Zhu et al., 2020), and delineation of health care market areas (Wang et al. 2020), rely on attainment of reliable drive time estimation from a set of origin locations to a set of destination locations. Such a task for a small-size matrix has become routine in many GIS and transportation packages, such as ESRI® ArcGIS and Caliper® TransCAD. However, it can be a challenging task for a large matrix. Most studies in this scope focus on small areas like individual cities or counties. Estimating the time matrix at larger geographic scales, such as a national scope, is of increasingly great importance to researchers and policy makers. Take the U.S. health care as an example, a national travel time matrix is the most critical component to study the average geographic access to health care (Onega et al., 2008; Boscoe et al., 2012), measure the variations in geographic access across regions (Onega et al., 2017), identify the areas where the health care geographic access is significantly lower than average, suggest the most appropriate sites for new care facilities, and facilitate the implementation of other strategies for reducing health care disparities such as remote health care, health care on wheels, and transit to care. The challenges for calibrating a large drive time matrix include availability of reliable road network (including traffic) data, programming expertise, and computational power. Many studies assume a free flow condition on roads to eliminate the data requirement on traffic, and are often limited to estimation of drive times from areas (e.g., ZIP code area, census tract) to the nearest locations (Onega et al., 2008; 2017; Boscoe et al., 2012; Ikram et al., 2015) or between locations within a short range (Shi et al., 2012) with a significantly reduced number of OD (origin-destination) pairs. Most recently, Saxon and Snow (2019) estimated a drive time matrix from each census tract to each primary care location within 62 miles (100 km) in the U.S. by tapping into advanced computing resources such as distributed computing and sophisticated algorithms, which may not be accessible by most researchers. They did not consider traffic conditions or node impedance, and the result tended to underestimate drive times especially for short trips. One way to account for traffic effect in drive time estimation relies on the utilization of traffic sensors or auxiliary data sources. These sensors include loop detectors (Kwon et al., 2000; Coifman, 2002) and automatic vehicle identification systems—such as toll collection system (El Faouzi et al., 2009), license plate recognition system (van Hinsbergen et al., 2009), and Bluetooth-based system (Bhaskar and Chung, 2013)—that are installed at certain locations along the road. They can accurately capture travel speeds and times. Other sensors are rather flexible, such as the floating or probe vehicles that consist of a sample of vehicles equipped with GPS units running with traffic (De Fabritiis et al., 2008). Based on collected information on a vehicle’s location, direction, and speed in a short time interval, drive times between any two locations in a network can be readily attained (Semanjski, 2015). A few recent studies attempted to estimate drive times using big data. Toole et al. (2015) used call detail records (CDRs) to obtain drive times for all road segments in five selected cities worldwide. Woodard et al. (2017) derived drive times on all roadways in the Seattle metropolitan region based on collected mobile phone GPS data. Although these methods can provide highly accurate estimates on actual drive times in traffic, their reliance on installation of physical equipment or big crowdsourced data restricts their usage to only small areas ranging from major corridors to metro regions. An alternative approach is to use third-party web mapping services such as Google Maps and MapQuest. For example, Google Maps Distance Matrix API uses the Google data such as its road network and collected traffic information to estimate drive times between a set of origins and a set of destinations. Similarly, MapQuest’s Route Matrix API uses open-source mapping data from the OpenStreetMap project to achieve this goal. Another benefit of using these commercial web services is to relieve analysts of the burden of preparing street network data and accessing GIS/transportation software (Boscoe et al., 2012). However, the free usage of these services comes with request limits. For instance, Google Maps offers free usage up to 40,000 OD records per month (Hu and Downs, 2019). A similar restriction applies to MapQuest. As a result, researchers usually use this approach to derive drive times for a limited number of OD pairs (Wang and Xu, 2011). Another issue related to drive time estimation between areas is the so-called aggregation error (Hu and Wang, 2016). The centroid-to-centroid approach assumes that all people in an area live at the centroid of an area (Hewko et al., 2002), and inevitably overlooks intrazonal travels (Kordi et al., 2012; Bhatta and Larsen, 2011). For example, the average commuting time within a traffic analysis zone (TAZ) is 11.3 minutes for auto drivers in Cleveland, Ohio (Wang, 2003). Given the average area of 82.25 square miles for the ZIP code areas in the U.S., intrazonal drive times at the ZIP code area level can be significant, especially in low-density suburban or rural areas. Its omission accounts for a high percentage in error for short-range trips. A common approach approximates intrazonal travel distance as the radius of an area-equivalent circle (Frost et al., 1998, Horner and Murray, 2002; Hu and Wang, 2015). Some recent studies use Monte Carlo simulation techniques to improve the estimation of trip lengths between area units (Hu and Wang, 2016; Hu et al. 2017), and offers a viable solution to intrazonal drive time estimation. This study seeks to estimate a very large drive time matrix between ZIP code areas in the U.S. ZIP code area is a popular geographic unit used in many nationwide datasets. For instance, ZIP code area is often the finest geographic scale at which health information is compiled and distributed in the U.S. (Berke and Shi, 2009). Our method (1) does not rely on intensive efforts in data preparation or access to advanced computing resources, (2) uses algorithms of varying complexity and computational time to estimate drive times of different trip lengths, and (3) accounts for both interzonal and intrazonal drive times. Both the program and results will be available for free download, and provide a valuable resource for researchers. This paper is available on arxiv under CC BY 4.0 DEED license. This paper is available on arxiv under CC BY 4.0 DEED license. available on arxiv [1T] his is a preprint of: Hu, Y., Wang, C., Li, R., & Wang, F. (2020). Estimating a large drive time matrix between ZIP codes in the United States: A differential sampling approach. Journal of Transport Geography, 86, 102770. https://doi.org/10.1016/j.jtrangeo.2020.102770

Stories, News & Mentions about OPENSTORE

Openstore’s Stories on HackerNoon