Appway

appway

Let's learn about via these 69 free stories. They are ordered by most time reading created on HackerNoon. Visit the to find the most read stories about any technology. Productivity Tools /Learn Repo It's called "Slack" for a reason. 1. Top 10 Productivity Apps to Make 2020 Your Most Productive Year Yet Welcome to Part 2 of the Tech Productivity Series 2. How Task Management Software Helps Achieve Productivity in a Post-Pandemic World Before the pandemic, roughly 30% of the part-time workforce was working remotely. It is estimated this will expand to at least 48% post-pandemic. Until the pandemic is over, it’s unclear exactly how much of the full-time workforce that can work remotely will continue to do so. 3. 5 Best Online Tools to Compress and Optimize Your Images Here are the 5 Best Online Tools to Compress and Optimize Your Images. 4. On Productivity Tools And Time Management With Julien Quintard, Founder Of Routine An interview with Julien Quintard on why he is building Routine and why productivity tools as we know it is going to change drastically in the a few quarters. 5. Maybe, Just Maybe, Writing Your Passwords On Paper Isn't So Bad? This is not a joke. Stationery stores and selling pocket notebooks with the word "PASSWORDS" written across the front. Inside are pages, with alphabetized tabs and spaces for you to record the website name, the username (login), and your password. Plus a space for notes. 6. The Placeholder Tools that Boost Productivity for Developers and Designers 7. Boost Your Productivity as a Developer With These 10 Tools Productivity is one of the important metrics for developers. Stay organized with this list of the essential tools for a developer to increase your productivity. 8. 10 Best Web Dev Tools of 2021 Top 10 Web Dev Tools in 2021 9. Startup Interview with Henry Shapiro, Co-founder at Reclaim.ai Reclaim is an intelligent calendar assistant that enables you to block adaptive time for anything you care about. Vote for us for HackerNoon's SOTY! 10. How to Merge PDFs Without Adobe Acrobat For a task or assignment, different members are responsible for different parts. So, it's very common that the team must conclude the respective results at last. If their results are in the PDF formats, they must merge the PDFs to reach the final result. There are still many other occasions that we need to merge PDF files. 11. 22 AI Tools You Should Know About List of top trending AI tools 12. How to Stay Focused When Coding: 8 Productivity Tips Your well-being, routines, motivations and how effectively you plan, all play a role in your ability to remain focused while coding. 13. apibeats: Get Notified on Slack When The API Changes apibeats is an API maintenance platform that lets backend and frontend developers collaborate, and notifies teams on Slack & Email when the API changes in any way. apibeats provides a complete environment for you to interact with your APIs. It lets you create collections of endpoints and watch them for uptime/downtime and changes in structure, test your collections by making requests without writing any code and document your API collections. 14. How Time Tracking is Reshaping the Future of Work If you are running a business or just started your own startup, it’s important you keep an eye out on every minute detail. In case you are hiring designers, software developers, and/or a team for project management, tracking total working hours is probably what you should be doing. 15. 15 Apps that Can Make You Productive Here, 15 amazing apps have been listed for increasing our productivity. 16. 15 Best Project Management Tools Project management systems are supposed to make the life of teams easier and the work process faster and more efficient. 17. MakeMySummary Software Update:  June 2020 We recently released an update for MakeMySummary. The following are the highlights of the update. 18. 🏅year in Review: Tools That Helped my Productivity as a Software Engineer As a software engineer, you have to find the perfect mix of tools and templates that can help make you more efficient in your day-to-day tasks. 19. 4 Productivity Hacks That Yield Quick Results Having trouble hitting deadlines and staying focused? Well, have no fear! This article will introduce four productivity hacks that almost anyone can implement immediately and see fast results. 20. Writing a Slack Bot that Responds to Action Commands I recently wrote a slack bot that responds to action commands (like /ech yolo ) but I ran into some trouble finding exactly how to do this, so I’m documenting it here for other peeps to find. The exact error I hit was /echo failed with the error "dispatch_failed" . 21. NPX Introduction: Fast Work With NPM Package Binaries With Node.js, building CLI utilities and development tools have gotten so much easier. 22. Essential Productivity Tips Every Software Developer Should Know Here are the game changing productivity hacks, tools, and tips that have helped me most as a software developer. 23. 17 Killer Web Apps to Increase Productivity 🚀💯 24. 5 Team Communication Tools That Will Skyrocket Your Productivity Teams come in all sizes and these days from all parts of the world. Geography is no longer a limitation with messaging tools that can connect you with anyone in the world. The right communication tools can skyrocket your team’s productivity, as ability to easily share information and ideas with all your stakeholders is key to driving productivity. 25. Windows 11's New Focus Mode Is Pretty Useful The new Focus Mode feature is a useful tool that helps you get more productivity out of Windows 11 in a simple way. Though that simplicity does cut both ways 26. How to Improve Developer Productivity Become more productive as a developer in the next 10 minutes using researched backed tips and hacks. 27. Summarizing Youtube Videos and  News/Blog articles I made a new app/service that lets users summarize the deluge of info that comes our way every day. Its unambiguously named MakeMySummary. 28. Introducing CatalyzeX: A Browser Extension for Machine Learning Andrew Ng likes it, you probably will too! 29. How Nonprofits Can Get Adobe Discounts via TechSoup: FAQs Learn more about Adobe for Nonprofits, including information on eligibility, product licensing, downloading and installing software, and more. 30. How to Hack Your Team: Top 5 Tools For Team Management Automation in 2021 Wondering how to increase your remote team's productivity? These tools will help. 31. Top 10 Productivity Apps For iOS To Take Your Productivity To The Next Level Find the best productivity apps for iPhone or iPad. These best iPhone productivity apps help you get more things done faster and more efficiently than before. 32. Mind Hacking: Using Technology to Rewire Your Brain Like a Monk Not so long ago my life was an exercise in excel spreadsheets, over-scheduled phone calls, and constant emails. I was working in a high-pressure venture capital job, and putting myself in a state of mental fragmentation. 33. 4 Reasons You Shouldn't Use MoSCoW for Product Prioritization I often see MoSCoW being used to prioritise product development work, but for anything mildly complex (almost anything, really), and especially any product  with more than one customer, it isn’t appropriate. Here’s why. 34. How to Install RStudio on the WSL System If you are using Windows and don’t want to use the RStudio client on the Windows side, this method will work perfectly. 35. 6 Chrome Extensions That You’ve Never Heard Of But Should Try Out There are two types of people when it comes to using browser extensions. You have them all or you have them none. The adventure starts with just one install button. Then, you're lost in the extension world.  You’re adding a new one to your browser week by week. But what are the best Google Chrome extensions that you need to have? 36. Top 10 Javascript File Managers File management is a helpful tool in any business application. Here is an overview of the most functional, elegant, and popular JavaScript File Managers ready to be built into the client-server solution. Even if you do not have a direct need to work with files, you can borrow the classic file explorer interface for other tasks. For instance, there are some cases of the classic interface becoming the basis for a new web application in this article. 37. And Then He Said: Let's Fly Like an Eagle! Hi there, I'm Vadim, founder of Wedding Planning Assitant, and this is my three short stories about that. 38. How To Choose A Time Tracking Solution For Your Business: A Step By Step Guide As the impact of the COVID 19 epidemic on the global economy and societies starts to feel like less of a momentary blip on the radar and more of the new normal that we are all going to have to adjust to and get used to, people are getting used to the idea of working from home or remotely in some capacity. One of the technologies that have enabled this to happen and thus proven indispensable to the pandemic economy is time tracking solution. 39. The Fintech CTO's Guide To Remote Team Tools and Reviews Remote culture has never been so in demand before. The pandemic has changed the way we thought the world was likely to evolve in the nearest future. However, changes always go hand in hand with opportunities. 40. How Did Pocket Create a Habit Forming Product? A simple analyses of Pocket app using the infamous Hook Framework 41. 10 Features Where Coda Is Better Than Notion Notion vs. Coda: a look at 10 features in Coda that are better than Notion from the perspective of a Coda employee. This article has been updated for 2022. 42. 5 Productivity Tools Every Solopreneur Needs This pandemic is the perfect time to focus on your side hustle 43. Productivity 101: How to Implement the Pomodoro Productivity Technique If you’re looking to be more productive in your life, you may have heard of the Pomodoro productivity hack or technique. 44. 6 Incredible Productivity Tools for Programmers Productivity is key when it comes to getting work done with a smile. Burndowns are natural, here is how to minimize them and keep hustling. 45. Invoicing Tech Can Boost Brand Appeal Your brand is the essence of your company. It’s what your customers perceive you to be, and it’s how you portray your business to the world. 46. The Art of Mastering Atomic Habits If you want to change your life, you need to start with your habits. Atomic habits are the building blocks that make up our lives. 47. 5 Small Business Technologies You Can’t Afford to Ignore In an ever-changing world, staying up to date with modern business technologies can provide business owners with the leverage they need to be successful. This means being prosperous in their ventures and relevant in the competitive market. In most cases, using the correct types of technology will facilitate greater efficiency and even productivity. 48. Celebrating 10,000+ stars on GitHub repository⭐ ❤️️ Postwoman is celebrating the milestone of reaching 10,000 GitHub stars 🎉 49. 5 Tech Tools to Sharpen Your Creativity Creativity is important today because it helps us innovate and think outside the box. Knowing how to use your creativity can open up a world of opportunities, so it's worthwhile taking the time to sharpen these skills with the right tools. 50. Get Rid Of Your Self-Imposed Restrictions: An App Review of Freedom Want to improve your focus so you can get more done? Stop relying on self-discipline and use the Freedom app instead. 51. Without Digital Adoption, Your Enterprise will Struggle It’s clear to everyone that we’re living in a digital age. In a time when people expect to run their lives through their smartphones, competitive enterprises have no choice but to adopt digital tools. 52. 13 Must-Have Tools for Content Marketing in 2020 Hey there! If you’re looking for the best Content Marketing tool for your Business, stick here! Because I’ve made a list of tools for you that you need for your Content Marketing in 2020. I’ve used a lot of tools for my Content Marketing and shortlisted a few that are a must-have if you are to market your business through social media and Content Marketing. 53. 17 Apps to Boost Developer Productivity To help you build the ultimate workflow, we went looking for the developer productivity tools that are currently trending in coding communities. 54. 5 New AI Tools That Can Help You To Be More Productive How much of your productive time is taken away by all those meaningless news, stories and activities? Especially if you are a high performing executive or professional, how productive would you be if you weren’t distracted? We lose a lot of time on the activities that seem to be crucially important, while they are not. Although social media and numerous web-based communication platforms have definitely made communication a much less bothersome task, it is simply mind boggling to realize just how much of our time is spent on social media. 55. A Critical UX Review of Trello's New Features Trello recently launched new features and a business version. This could only mean one thing. It's time for a design review. 56. The Era of Opinionated Productivity Software: Superhuman, Roam, What’s Next? Productivity software is indispensable for all of us. Dedicated tools for creating spreadsheets, writing down notes, managing our to-dos etc. ensure that we are productive in our professions. Incumbent vendors (e.g. Microsoft, Google) have dominated this space for many years — yet, there is a chance for new players to enter the stage. New challengers such as the E-Mail client Superhuman or the note-taking tool Roam Research can compete by developing highly opinionated products which deliberately omit flexibility. Instead, the software is stringently crafted around a very particular way of approaching a process, which is inherently seen as superior by the firm. 57. How to Use Dora Metrics to Become an Elite Team Tradeoff between speed and quality is a myth. 58. How to Create a Habit Tracker in Notion Why Even Track Your Habits? 59. Automating Pull Request Merges with Mergify Mergify is a tool that helps prioritize, queuing, and automatically merge your pull requests. 60. 20+ Extraordinary Apps For Remote Teams I am sure that you already have Zoom, Slack and Asana on your computer. But daily office life is more than written tasks and planned meetings. There are lunches with your team, spontaneous talks near the water cooler, common tasks and goals you want to acheive. It’s your comfortable workplace and it by itself motivates you to be productive. Just look at the bunch of stickers on the wall — big things are waiting for you! 61. How To Improve Concentration: 2021 Edition How to improve your focus - especially as a software developer. Book review of Deep Work by Cal Newport. 62. Upgrade Your Note-taking With Roam Research “Personal Knowledge Management (PKM) is the practice of capturing the ideas and insights we encounter in our daily life, whether from personal experience, from books and articles, or from our work, and cultivating them over time to produce more creative, higher quality work.” 63. Notion: Superior Productivity For All Notion is an All-In-One workspace. Notion’s platform allows you to create task-oriented lists and projects, wikis, databases, lightweight CRM’s, tables & more! 64. InVision Gains 2 Million Users, Adds Freehand Templates (Interview) After a year that included 40% growth in user base and a 130% surge in demand for online whiteboard products, InVision has released an update with Freehand template gallery. 65. Top 10 Business Development Tools in 2020 and 2021 Slack, Rocketbolt, and Trello are among the best business development tools in 2021. In this article, we'll go over 10 tools your business should consider. 66. 6 Tools to Help SMBs Hack Productivity in 2020 The approach of the new year is always a great time to revisit all the awesome things your SMB has achieved and pat yourself in the back about how great things are running. 67. The Zen of Python: As Related by Masters The Zen of Python saw light for the first time in 1999. It's one of the many aspects that adds to the awesomeness of Python. It's a set of expressions which corners the spirit of the language. It was enounced by Tim Peters, a reputable software engineer, master Pythonista and Python's 'most prolific and tenacious core developer' in the words of none other than Guido [18]. This article bases itself mostly on the saying of core devs and highly reputable members. It makes a great gift to all those interested in the history of the sysadmin script which took the world by (pleasent) surprise. 68. All You Need To Know About SharePoint Migration Learn how you can simplify SharePoint Migration process easily with the best SharePoint Migration Tools. 69. The Best 75 Evernote Alternatives:  Complete Review Has Evernote become a unicorn that has stopped caring about its core users while trying to attract broader markets? Thank you for checking out the 69 most read stories about Productivity Tools on HackerNoon. to find the most read stories about any technology. Visit the /Learn Repo

69 Stories To Learn About Productivity Tools

It’s Tuesday at 8:32 a.m. Sarah, a facilities manager, is darting off to work. She offers a quick goodbye to her twelve-year-old daughter, who’s texting a friend and listening to music on her Bluetooth headphones. Sarah gets into her EV, which automatically connects to her phone, and begins playing a song from her 80’s playlist. Upon Sarah’s entry, the car adjusts the seats and steering column height according to her preferences. On the drive to work, she uses a virtual assistant to call her husband to remind him of a dinner commitment that night. Finally, Sarah gets to work and wants to run an energy consumption report for two of her buildings. However, her submeter app and her energy dashboard don’t connect natively. Frustrated, Sarah calls her integrator for help. They give her an estimate of a week. Most of us understand Sarah’s frustration. It’s almost absurd how much connectivity, personalization, and power we possess in our ordinary lives that isn’t translated to working with buildings. Like Sarah, we often think: “ is ” Why the hell is this so hard to do when using our personal devices so easy! There’s a reason why Sarah and many of us in the automated buildings industry have this experience. All our everyday gadgets and technology today use cloud-native architecture. Imagine if your building gave you as much power to connect, to manage, and to create as your smartphone did. In general, the automated buildings industry has been slow to adopt cloud-native technology, and our buildings and stakeholders like Sarah are paying the costs. But there’s a way for the industry to embrace the power of cloud-native and transform our properties into powerhouses of integration and automation. It’s the Interoperable Building Box or IBB from the Coalition for Smarter Buildings ( ). C4SB Why Do We Need an IBB? Today, the smart buildings industry is facing an onslaught of challenges and disruptions from multiple sides. Building information systems are getting increasingly complex—more sensors, more points, more systems, AI, and digital twins. We have a flood of information and streams of data, yet no single nozzle that will do the work of putting out the fire. We also have incredible applications that do wonderful things, but getting them to work and communicate with each other seems to always be a Herculean task. The amount of effort and time is a major pain point for folks like Sarah, who expect things to work as easily as everything else in their lives. For most, the benefits of integration outweigh the level of effort. This is the main reason for the slow adoption rate. only just The industry’s slow shift to cloud-native is revealing a serious skills gap. Cloud-native has been the standard architecture for IT departments for years now, and the onboarding of OT into the cloud-native space is beginning to blur the lines between the two. IT and OT are converging, and knowledge of both is becoming a prerequisite. Today, it’s difficult to find enough workers with the skills and knowledge level to tackle both. All these challenges hobble the goal of delivering smart technology at scale. Overcoming these obstacles requires technology that facilitates app integration while also improving the experience of industry stakeholders like Sarah. Instead of retooling our entire workforce, we can retool the way we interface with building systems. What is an Interoperable Building Box or IBB? Let’s start with a technical definition: The IBB (Interoperable Building Box) is orchestration software running on a physical or virtual machine that exists on-prem; the IBB acts as a standardized interface to connect a building’s local network to the . The IBB runs containerized cloud-native applications and services based on the Open Container Initiative ( ) standard. The IBB makes deploying and managing containerized software easier and more secure and provides an automated way for systems to discover and connect with systems having matching capabilities both within the IBB or in the Cloud in a plug-and-play manner. Internet Cloud OCI The purpose of the IBB is to make a building cloud native. That is, all its technologies and apps are built to work within (i.e., “native to”) a cloud environment. It must also support standard cloud functionalities like containerization, dockers, and orchestration (Kubernetes). By functioning like a standard cloud provider, the IBB allows the building to reap the advantages of localized control, namely better resiliency, security, and faster access. inherently Imagine “A Smartphone for Your Building” In a way, you can think of the IBB as a “smartphone for your building.” Consider all the ways your phone expands your capacity to do things. You can talk to anyone, anywhere, at any time. You can download, install, and run almost an unlimited number of apps. You can connect to the internet, access cloud storage, store local data, share files with your computer, and connect to wireless devices. In the same way, the IBB expands your building’s potential by providing it greater power to communicate and connect. Overall, your property becomes exponentially more efficient and productive. And because the IBB is located on-prem (i.e., in your building’s “pocket”), it can reliably deliver secure local storage of sensitive data and low latency times. For example, data from equipment sensors need not make the long round-trip to a cloud platform and back again. Data storage and computation are already . Such local processing makes storage of sensitive information more secure, while low latency times help protect critical systems and sensitive equipment, while the cloud connection automatically creates a copy of such data for backup and analysis in the cloud. This is analogous to taking a picture on your smartphone; you can see the image immediately, and it is also stored in your cloud photo album. in the building Parts of the IBB At the heart of IBB is containerization—a technology for packaging, distributing, and managing applications in a self-contained unit (i.e., “containers”). Containers house everything an app needs to run, and this isolation makes them lightweight, portable, and consistent. Since multiple containers can run on the same IBB, they share the required computing resources (CPU, memory, etc.). cloud-native The IBB consists of three main parts: , , and . These parts function together to make deploying and managing containerized apps easier and more secure. Operating System (OS) Administration IBB Apps (OS) Operating System Like a great deal of cloud-native computing environments, IBB runs on Linux, either on bare metal hardware or on a suitable Virtual Machine. The OS layer of the IBB also includes the open-source Kubernetes (often known as k8s) orchestration platform that manages IBB App containers. The OS layer of the IBB also includes other open-source software to further automate the management of IBB Apps. Administration The admin area of the IBB provides the tools for administrators to install and manage containerized applications. This includes software for the management of IBB Apps installed in the IBB, as well as user access and security policies and management. These admin tools provide admins access to the IBB remotely, using secure proxying mechanisms. IBB Apps These are the Apps and services provided by Independent Software Vendors (ISVs) that are installed in the IBB by admin users using the Admin tools provided. Each IBB App exists in its own container environment and thus operates separately from other containers (as if in its own hardware environment). Each IBB App communicates with other IBB Apps using IP networking with the help of IBB orchestration. Improving Stakeholder Experience IBB implementation improves the experience for all stakeholders because it simplifies the integration process. Currently, building owners and managers like Sarah need to employ capable folks with specialized knowledge to get things to work together. The process is complex, time-consuming, and expensive. The IBB takes the complexity out of the process by facilitating plug-and-play workflows. Let’s see how this works by following the process of installing and configuring an IBB using two different personas. IBB Installation Both HVAC and IT engineers can use familiar workflows and tools when installing and configuring an IBB. Here are the steps for installing an IBB for an HVAC Engineer and a DevOps: —Jake is tasked with installing a physical IBB device. He orders a suitably specified IBB-compatible device from his trusted vendor (CPU, memory, storage, etc.), takes it to the site, fastens it to a wall, connects it to the network, and on his browser, navigates to the IBB’s address and the IBB “Welcome” page. Jake (HVAC Engineer) —Mandy is tasked to install an IBB in a Virtual Machine on-prem. She navigates to the IBB repository on GitHub, looks over the IBB installation instructions, downloads the code, installs the IBB in the VM using her standard DevOps tools, and navigates to the IBB’s address and to the IBB “Welcome” page. Mandy (DevOps) Both Jake and Mandy were able to work in ways comfortable with their respective experience and skillset to achieve similar results; Jake through physical “box” installation that he was comfortable with, and Mandy used online “virtual” tools she uses daily. These flexible workflows and tools speed up the integration process. IBB Configuration Once installed, Jake and Mandy will need to configure the IBB to their specific needs for the building. On the IBB “Welcome” page, Jake/Mandy find a list of management platforms that support the IBB. They select the platform being used for their building project. In this example, they choose . Next, they login into the portal. The IBB is now installed and configured to the appropriate management platform. Acme X Cloud Acme X Cloud Acme X Cloud Now, let’s continue the configuration, considering Jake’s workflow. App Installation Once the configuration is complete, Jake can install and manage applications. He begins by choosing the “Install IBB App” option in the management platform (i.e., ). Next, he selects the app he wants to install. In this case, he wants to install a Haystack IDL (Independent Data Layer). Jake configures the app as necessary. The IDL app is installed, and Jake is presented with its UI. Acme X App Integration Next, Jake wants to install a dashboard required for the IDL. He uses the same IBB management system to install and configure the dashboard. The dashboard is then automatically connected to the IDL and runs the way Jake configured it. That is, the dashboard is running in the IBB, and it’s also connected to the IDL because they have compatible capabilities. Both Jake and Mandy can work efficiently and productively using their own skills and knowledge. Jake knows the apps he installed are compatible and already comply with IT policies. Mandy knows that the IBB is either a well-managed physical device or a virtual device she herself can oversee. More importantly, both engineers work within the purview of their own skill set. That is, they need not know anything about what the other does. In this way, the IBB helps ameliorate the industry’s skills gap. Instead of retooling our entire workforce, we can retool the way we interface with building systems. Vendors and End Users As was stated earlier, the idea of cloud-native architecture and containerization isn’t new; it’s only newly applied to the building automation industry. For years, app developers and the IT industry have built massive ecosystems that support and expand these technologies. Every time you use the Internet or your smartphone, you are using cloud-native. Everyone benefits, and now buildings can reap these benefits with the IBB. For example, mobile app developers follow common standards and protocols within both the iOS and Android platforms. The standards give developers dependable and consistent guidelines that make app deployment easy. Moreover, markets like Apple Store and Google Play ensure these standards are followed. Customers who download these apps can trust they are secure, reliable, and compatible with their devices. There’s no need to call someone to integrate your Instagram app to your iPhone. It just works. Now, contrast the above with today’s automation industry workflows, where thousands of vendors and developers create apps built with a disparate collection of proprietary standards, protocols, and guidelines that run on different platforms. Some are cloud-native, but most aren’t. With the support of vendors and the automation community, we can adopt the IBB and cloud-native architecture to create a collaborative ecosystem that would unleash the functionality and creativity of the entire industry. Conclusion The IBB not only holds the promise of streamlined integration and enhanced efficiency for the smart buildings industry, but it also addresses the very frustrations experienced by stakeholders like Sarah. For her, the dream of plug-and-play apps for her building is in reach. The IBB will result in a disruption to the entire industry by changing the way we develop, deploy, and manage our apps and data. Cloud-native offers the freedom and power our industry needs to leap forward and meet Sarah’s expectations. Moreover, the IBB’s benefits ultimately trickle down to the building’s users, tenants, and occupants. Also published . here

Introductory Guide to the Interoperable Building Box (IBB)

In my , I have shown a way to unify the implementation of the most well-known graph-traversal algorithms. Now, let's make it more visually appealing and look into the performance differences. last post The story behind A few years ago, Yandex organized a contest called with an enticing prize: a ticket to a . The contest resembled a game, with participants tasked with finding optimal routes on a map and optimizing delivery using robotic couriers. Robots Couriers closed self-driving conference for professionals As I delved into the topic, I discovered that despite route finding being a solved problem, it continued to interest the professional game development community. Between 2010 and 2020, engineers , particularly beneficial for AAA games with massive maps. Reading on these optimizations was an exciting experience. made significant optimizations to the A* algorithm articles and research papers Furthermore, the contest requirements were designed to enable easy assessment of program outputs by the contest’s testing system. As a result, there was little emphasis on visualization. I found exploring this field intriguing and developing a small application that uses well-known graph algorithms to find routes on a grid map. To visualize my findings, I employed the SFML graphics library. Goal This project builds upon one of , where I demonstrated that four well-known path-finding algorithms (BFS, DFS, Dijkstra's, and A*) are not fundamentally different and can be implemented in a universal way. However, it was challenging to showcase significant performance differences among these algorithms in that project. my previous endeavors In this article, I aim to use improved test data and design something visually exciting. While the Yandex Contest task mentioned earlier aligns well with my goals, I will not solve their specific problem here since it heavily relies on their test system, which is currently unavailable. Instead, I will extract general ideas for input parameters from that contest and create my own implementation. Imaginary world Imagine a technically advanced and innovative city where the future has arrived long ago. In this city, the majority of orders are delivered by courier robots, and it has become a rarity for a person to deliver an order from a cafe. In this task, we invite you to participate in finding optimal routes to deliver orders efficiently. Let's envision the city as an N × N map. For simplicity, we assume that each robot occupies exactly one cell, and each cell can either be passable or not for the robots. In one step, a robot can move in any of the four cardinal directions (up, down, left, or right) if the target cell is free. And I'm of the original task: ignoring the rest At the beginning of the test, you need to output the number of robots you want to use to deliver orders and their initial coordinates. The construction of each robot will cost Costc rubles. Next, T iterations of the simulation will be performed. One iteration represents one virtual minute and consists of 60 seconds. At each iteration, your program will be given the number of new orders, and in response, the program should tell you what actions each robot performs (60 actions per robot). For each successfully delivered order, you will receive max(0, MaxTips - DeliveryTime) dollars in tips, where MaxTips is the maximum number of tips for one order, and DeliveryTime is the time from the moment the order appeared to its delivery in seconds. The total number of points that you earn in one test is calculated by the formula TotalTips - R × Costc, where TotalTips is the total number of tips earned, R is the number of robots used, Costc is the cost of building one robot. The Costc and MaxTips values are set in each test. If you earned less tips than you spent on making robots, your total points will be 0. You will also receive 0 points for the test if you perform any incorrect action. Input The program uses standard input to read the parameters. This approach allows us to specify test data of various complexities using input files. The first line of input contains three natural numbers: N (the size of the city map), MaxTips (the maximum number of tips per order), and Costc (the cost of building one robot). I ignored both MaxTips and Costc parameters for my first implementation and maybe will consider that in the future. Following that, each of the next N lines contains N characters representing the city map. Each string can consist of two types of characters: '#' - indicates a cell occupied by an obstacle. '.' - indicates a free space. Next, you will be provided with two natural numbers: T and D (T ≤ 100,000, D ≤ 10,000,000). T represents the number of interaction iterations, and D represents the total number of orders. Output Your task is to visualize the map and the optimal routes using the SFML graphics library. Modelling the maps I'm fond of maps represented as a grid of cells. Thus, I prefer to render all the results and map them as a grid on cell by cell basis. There is also the option to execute path search right on the grid without using any additional data structure (and I have implemented this as well for learning purposes: see in code). But because of a grid, it is easy to represent a map as a graph in one way or another. I prefer to use an adjacency list of cells for most of the algorithms like BFS, Dijkstra's, and A-Star. For algorithms like Bellman-Ford, it may make sense to use an Edges List instead of an Adjacency List. That's why if you explore the codebase, then you will find all of it, and they all are working examples. To split the logic and responsibility, I have a entity that is responsible for executing path finding according to the orders and tasks configuration that is specified via the file and related map files. Navigator App Config looks like this: App Config {
    "font": "../../data/arial.ttf",
    "map": "../../data/maps/test_29_yandex_weighten_real_map",
    "shadow": false,
    "map_": "../../data/maps/test_08_low_res_simple_map",
    "map__": "../../data/maps/test_10",
    "map___": "../../data/maps/test_07_partially_blocked_map",
    ... Note that "map_” "map__" etc. are not really configuration properties. They are ignored during the application run. Since there is no way to comment on the part of the JSON file, I use underlining in the property name so it can stay in the config file but not be used. looks like this: The map file 25 50 150
#########################
#########################
#########################
###.......#####.......###
###.......#####.......###
###.......#####.......###
###...................###
###.......#####.......###
###.......#####.......###
###...................###
######.###########.######
######.###########.######
######.###########.######
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
###.......#####.......###
######.###########.######
#########################
#########################
#########################
#########################
2 4
2
6 6 4 20 This is one of the simplest examples that contain either blocked or not blocked cells. I have prepared a lot of various examples of input parameters and test data. Starting from very small parts that let you debug and learn the code, finishing with a huge piece of map (from the real existing city) that allows us to measure the performance of a Graph algorithm. How do we draw such maps? When a map contains only cells with binary state (either blocked or non-blocked), this basically means that any edge of a graph either exists or not. To find a path in the graph, we have to represent it efficiently. Like in my previous post, I have used an with the relationship as Vector[NodeId]->points to->Vector[Neighbour Nodes]: adjacency list typedef std::vector<std::vector<std::shared_ptr<Cell>>> Graph; When we exploring grids it's not really necessary to use graphs at all. We are capable to traverse grid using BFS/DFS algorithms cell by cell without thinking about edges. See method for example. _GetPathByBFSOnGrid First, the initialization code reads the file and converts it into row by row and column by column: the grid bool RectangularMap::LoadMap(const std::string& filepath, bool shadow)
{
...
  // Fill the grid.
  _verticesNumber = 0;
  for (int row = 0; row < _height; row++)
  {
    ...
    for (int col = 0; col < _width; col++)
    {
      int x = col;
      int y = row;
      if (line[col] == BLOCK_CELL)
      {
        // Create a shared pointer here to safely pass pointers between the classes.
        _grid[row][col] = std::make_shared<Cell>(x, y, line[col], blockColor, shadow, _scaleFactor);
      }
      else
      {
        ...
      }
    }
  }

  // Make a graph
  InitialiseGraph();
...
} Then, it creates an actual graph as : an adjacency list void RectangularMap::InitialiseGraph()
{
  MapBase::InitialiseGraph();
  ...
  unordered_set<int> visited;

  for (int rr = 0; rr < _grid.size(); rr++)
  {
    for (int cc = 0; cc < _grid[rr].size(); cc++)
    {
      if (_grid[rr][cc]->GetId() > -1)
      {
        for (int i = 0; i < 4; i++)
        {
          int r = rr + dr[i];
          int c = cc + dc[i];

          if (r >= 0 && c >= 0 && r < _width && c < _height &&
              _grid[r][c]->GetId() > -1)
          {
            if (_isNegativeWeighten)
            {
              ...
            }
            else
            {
              _adjacencyList[_grid[rr][cc]->GetId()].push_back(_grid[r][c]);
            }
          }
        }
      }
    }
  }
} Grid representation is useful to draw on the screen using the SFML library. We can draw (this is exactly what I do for small maps): by creating a geometric object ...
for (int j = _visibleTopLeftY; j < _visibleBottomRightY; j++)
{
  for (int i = _visibleTopLeftX; i < _visibleBottomRightX; i++)
  {
    _grid[j][i]->Draw(_window, _scaleFactor);
  }
}
...
sf::RectangleShape tile;
tile.setSize(sf::Vector2f(_cellSize - 5, _cellSize - 5));
tile.setPosition(sf::Vector2f(_x * _cellSize, _y * _cellSize));
tile.setFillColor(_color);
window.draw(tile); Or we can do it for larger maps: efficiently pixel by pixel sf::Uint8* pixels = new sf::Uint8[_width * _height * 4];

for (int j = _visibleTopLeftY; j < _visibleBottomRightY; j++)
{
  for (int i = _visibleTopLeftX; i < _visibleBottomRightX; i++)
  {
    int index = (_grid[j][i]->GetY() * _width + _grid[j][i]->GetX());

    sf::Color color = _grid[j][i]->GetColor();
    pixels[index * 4] = color.r;
    pixels[index * 4 + 1] = color.g;
    pixels[index * 4 + 2] = color.b;
    pixels[index * 4 + 3] = color.a;
  }
}

sf::Texture texture;
texture.create(_width, _height);
texture.update(pixels);
sf::Sprite sprite;
sprite.setTexture(texture);
sprite.setScale(cellSize, cellSize);
_window.draw(sprite); Finally, let's see what a map defined by file would look like. Originally, the file defined this: test_25_xmax ..............C.................
..............#.................
.............###................
............#####...............
...........#######..............
..........##1###2##.............
.........###########............
........##3######4###...........
.......###############..........
......#################.........
.....###################........
....#####################.......
.............###................
.............###................
.............###................ And a map renderred with SFML looks like this: Because I wanted all of that to be controlled by the user with the keyboard, I left all the user-behavior logic in the . I like to call it “Controller” logic. main.cpp SFML library makes it very easy to handle keyboard events: while (window.isOpen())
{
  Event event;
  while (window.pollEvent(event))
  {
    if (event.type == Event::Closed)
      window.close();

    if (event.type == Event::KeyPressed && event.key.code == Keyboard::Space)
    {
      ... Do what you need here
    }
  }
} The main idea is for user triggers (press of a SPACE button) to read the map file and rendering the map, and then by a second trigger (second press of a SPACE button) to load the routing task and calculate the shortest path between two points on the map: ...
if (navigator->IsReady())
{
  navigator->Navigate(); // Finding route between two points
}
else
{
  if (map->IsReady()) // Second SPACE press runs the routing
  {
    skipReRendering = true;
    if (navigator->LoadTasks(filepath))
    {
      navigator->SetMap(map);
    }
  }
  else // Load and draw map
  {
    drawLoading(window, font);
    if (!map->LoadMap(filepath, shadowed))
    {
      return 0;
    }
    drawProcessing(window, font);
  }
}
... We need to go deeper I wanted to play with more Graph algorithms, and they all have their limitations, so I decided to implement multi-color maps that can be represented by multi-weighted graphs. Every cell is colored, and the color means that the edge not only exists but also applies some weight (or fee, or fine, you name it). So, the edge might be blocked, half blocked, not blocked, ... you got the idea. Thus, I have implemented multi-color maps that look more joyful and look like a game-ready (example from file ): test_31_multi_weight_graph_map Some of the configuration files contain more complex maps from really existing cities, like : test_29_yandex_weighten_real_map As a challenge, now we should handle maps with very flexible configuration. essentially contains a lot of logic inside, including all the graph algorithms and even more than needed (because I like to play with things, even if it's not particularly useful for now). RectangularMap.cpp I have implemented , , , algorithms, and a number of additional "utility" algorithms like Topological Sort, Single Source Path, that are not useful for the current application state (because they work on Directly Acyclic Graphs, which are not type of Graphs I currently use), but I have some ideas to use it in future improvements. BFS#Line 598 Dijkstra#Line 299 A-Star#Line 356 Bellman-Ford#Line 428 I didn't polish all the code and didn't get it ideal enough, but it allows me (and, I hope, will allow you) to play with the code and compare performance metrics. Sorry about some commented lines here and there, maybe some dirty code...it's all way of learning :). To grasp an idea of what's inside, I recommend you review the . RectangularMap.h There are also some fun features, like a Focus feature that allows one to render only a particular part of a map. It changes focus by re-rendering the necessary part using the when the user presses the PgDown or PgUp buttons. It is pretty easy to improve this feature and implement "Zoom" functionality. Take it as a homework, if you like it. Observer pattern Focus feature with map file in work: test_29_yandex_weighten_real_map Classes diagram looks like this: Run and play I believe the most joyful part is just running this little application is playing with variations of its configuration and algorithms. You can do a lot of experiments by using various map files as input parameters with different test data as well as change the logic in the code. After starting, you need to press SPACE an application will render a map according to the configuration file, and it makes a lot of sense to start exploring from the simplest test cases and moving forward to the most complex ones. Pressing SPACE one more time executes the routing algorithms and finds the path between the start and the nearest order. BTW, It's not yet done, but it is easy to implement reading all the rest of the orders available in map configuration files and execute pathfinding to all of them. Here is the route found on the map defined by file : test_18_yandex_super_high_res It is also capable of finding routes in the maps that simulate existing cities, like : test_29_yandex_weighten_real_map Finding efficient paths between two coordinates becomes challenging for algorithms like BFS but can be easily done by A-star. Based on the cells found in the map configuration files, the application will treat the map as a weighted or non-weighted graph and will select the right algorithm for it (and you can easily change this as well). It's easy to see the difference between BFS and A-Star performance: Final words With this, I want to leave you alone and let you play with these code examples. I hope you will find it fascinating and will learn a lot from it. Stay tuned! Links JPS+: Over 100x Faster than A* by Steve Rabin A* Optimizations and Improvements by Lucho Suaya https://hackernoon.com/bfs-dfs-dijkstra-and-a-star-are-basically-the-same-algorithm-ill-show-you-why My blog https://antonyarkov.substack.com/ Also published . here

Graph Traversal Algorithms: Visualizing Performance Variations in Route Finding Algorithms

198 Stories To Learn About Technology

164 Stories To Learn About Nlp

130 Stories To Learn About Low Code

Table of contents What is Vite? How does Vite work? Why use Vite over CRA? Performance Hot Module Replacement(HMR) Native ECMAscript module support Rich Features Prerequisites Creating a Project with Vite Conclusion Create React App (CRA) has long been the go-to tool for many developers of all skill levels when it comes to constructing a React app (beginners, intermediate and even experts). It does, however, have some significant drawbacks, which are speed and performance. It is well known that CRA can be somewhat slow while building a project and setting up a development server, requiring around 5-10 minutes (depending on factors like hard disks, and internet connectivity issues). Time typically adds up, which is why I'm going to introduce you to a tool called . Vite is a build tool similar to Webpack (CRA uses Webpack beneath the hood). More information is available ).) Vite here In this article, I'll walk you through the process of building a React App with Vite. You will learn the differences between CRA and Vite, as well as some of its features and benefits, and also how to create a React App with Vite. What is Vite? Vite, pronounced , like "veet" is the next generation in frontend tooling. It focuses on speed and performance by improving the development experience for modern web projects. /vit/ Vite is created by Evan You, who is the creator of Vue.js, but it's not a Vue-only tool. It can be used for React, Preact, Svelte, Vue, Vanilla JS, and LitElements. It consists of two major parts: A dev server which provides support for Hot Module Replacement (HMR) for updating modules during the execution of the application. When changes are made to the source code of an application, only the changes are updated, rather than the entire application. This feature helps speed up development time. A build command that bundles your code with Rollup, pre-configured to output highly optimised static assets for production. How does Vite work? At its core, Vite does 2 things: Serve your code locally during development. Bundle your Javascript, CSS and other assets together for production. There are other tools(bundlers) that do the same thing, such as webpack, Parcel and Rollup, so what makes Vite different? The problem with the tools mentioned above is that they have to build everything on every save, and if you have a very large application, that could take several minutes every time you save, even with Hot reloading in some frameworks, the update speed gets significantly slower as you add more code and dependencies to the app. Vite has taken a different approach to this, kind of a reverse approach. Vite starts the server right away, takes the dependencies that don't change often, and pre-bundles them using . esbuild is a Javascript build tool written in Go, which pre-bundles dependencies 10-100 times faster than Javascript-based bundlers. Esbuild Let's take a look at the illustrations below to get a better understanding of how it works. The above diagram represents a traditional bundle-based development server, where we have an entry point, the possible routes and all the modules, which are then bundled together, and then the development server is ready. Vite, on the other hand, uses route-based code-splitting to figure out what parts of the code actually need to be loaded, and doesn't have to pre-bundle everything. Vite serves the source code using native ES Module support in modern browsers. This lets the browser take the job of bundling in development, which consequently makes your code to load instantly, no matter how large the app is. It also supports Hot Module Replacement for an extremely fast feedback loop during development. When building for production, Vite uses Rollup under the hood, so you don't have to worry about configuring it. Why use Vite over CRA? You may be asking why you should use Vite now that we've covered what it is and how it works. We've gone through a few benefits in the previous section, so I will just highlight them here. Performance Pre-bundling with ESbuild makes it 10 to 100 times faster than using any other JS bundler. This helps improve page speed and convert CommonJS / UMD modules to ESM. Hot Module Replacement(HMR) Vite uses HMR capabilities to keep track of changes in your application without reloading the full page. With the HMR API, the browser will only load the modified section of the page and still retain the application's state. You don't need to manually set these up - when you create an app via , the selected templates would have these pre-configured for you already. create-vite Native ECMAscript module support Vite supports ES modules natively. It allows you to develop for the browser with bare imports like Typescript and it converts them into properly versioned imports on build. Rich Features Out-of-the-box support for TypeScript, JSX, CSS and more. Check out other Features . here Prerequisites Before using Vite, you'll need a couple of prerequisites: or higher Node.js version 14.18 Package manager - or Npm Yarn Compatible browser for development The third requirement is a browser that supports . You can check to see if your browser is supported by visiting: . dynamic imports caniuse.com/es6-module-dynamic-import Most modern browsers are supported, with the exceptions being Internet Explorer, Opera Mini, and the Baidu browsers. But if you're on a somewhat recent version of Chrome, Edge, Safari, or Firefox, you should be all set. Creating a Project with Vite To application, open your terminal and navigate to the folder where you want to save the Vite program. Then run this command: create a Vite npm create vite@latest You'll be prompted to select a framework and a variant(template). In our case, we'll be using React, so select React. You can also directly specify the template you want to use and the project name in one single line: npm create vite@latest my-react-app --template react Note: is the name of the Vite application that we want to create. You can change it to whatever name you prefer. my-react-app Next, run the following commands in the terminal cd my-react-app
npm install
npm run dev Moving on... Running the above command will start the development server. Then open your browser and enter . http://localhost:3000 You should see a React logo with a counter and a button, as shown below: Conclusion There we go! We've looked at what Vite is, how it works, and some of its features. We also learned how to set up applications using Vite. For this project, the create vite app command was set up in 10 seconds. After which I ran to install dependencies, which took 35 seconds. So, all in all, the project was set up in 45 seconds. Which I'm sure you'll agree is way faster than CRA ;-) npm install I would love to hear your thoughts in the comments section, and if you enjoyed this post or found it insightful, kindly share it with your friends and colleagues. Also, consider subscribing to my blog. Till next time, thanks for reading, and happy coding! Before you go, here are some to check out. community-maintained templates Also published here.

Why Vite is Better Than Create-React-App (CRA)

Do we even need user authentication It’s 2022 the Web is nothing like the Web 20 years ago. Keeping track of user data is a must and this is achieved through user authentication. There are many ways to authenticate users one of which is using a username and password and storing users’ credentials in a database of your own which is no easy task to accomplish. Another way to do it is OAuth or simply using a third-party authentication provider like Google for example. In this blog, I will be introducing you to Faceio’s face recognition authentication which is an amazing way to log in users to your systems as well I will be building a simple app to showcase the way to integrate this mind-blowing technology in a react application. So tighten your belts there will be plenty to cover. Why facial recognition The first reason that makes this technology so attractive for a business is the fact that AI-powered technologies in which facial recognition makes part, are just mind-blowing. My self I wouldn’t believe it works before making my own app that uses it. Just the fact that your website uses face recognition will make users want to visit your website and try your authentication system. The second reason why you should consider face recognition is how easy it is to integrate this technology into your application. And to showcase this, we will be building a react application with FaceIO’s facial recognition from our mobile phones which seems to be unreal but this became possible with the fio.js library which takes all the heavy lifting for us we can easily use face recognition. The third reason is simply that this authentication method is very user friendly so you don’t have to remember passwords or else although you can add two-layer user protection which is a pin in faceio’s case and also as a user you just have to let the camera scan your face and you’re done. User security with face recognition authentication From a user standpoint, it doesn’t matter how great your application is if your data isn’t secure. But facial recognition is a very secure way to authenticate your users. Why? Actually for many reasons. First comes Faceio’s compliance with broadly applicable privacy laws such as the GDPR, CCPA, and other privacy standards. Such laws may charge businesses up to 4% of their annual revenues for violating their rules concerning users’ privacy. Also, FaceIO never stores your image it just stores a hashed key of the image so you’re photos are not getting anywhere you can know more about data security by clicking here . https://faceio.net/trust-center In second place comes the high accuracy for which FaceIO is known. In fact FaceIO’s engine case, accuracy is 99.8% which is insane. Being someone who has been involved in the AI field before I can tell you that achieving such a rate is extremely hard and needs an insane amount of data which is very expensive. Making a login system with FaceIO We’ve talked enough and I know you’re not here to talk but to see things work so let’s go straight for the implementation. The app will be simple, there will be 3 buttons one for registration, another one for login, and the third one to log out. The app works in a simple way you first register and then log in, at this point the logout button that was originally hidden shows up and the other buttons disappear. You can check the final version of what we’re going to build when clicking this link: https://housseinbadra.github.io/FaceIodemo.github.io/ First, you need to get your own FaceIO account if you don’t have an account it’s an easy thing to do, once you have an account login, I will be waiting for you to get ready. To signup with FACEIO click here: . https://console.faceio.net/ Once done you’ll have a Public ID associated with your application that looks something like fio9362 . We’ll need this Public ID to connect with our application So now since you’re done setting your account up it’s time to code. I told you that this app will be totally built on a mobile phone. All that we need is 3 files an index.html, an index.css, and an index.js file. So download any code editor or even go with code pen if you want to, I downloaded the SPCK editor which is a great tool. Once done create a folder and create these 3 files Your file structure should look like this: Now let’s start with the CSS, add these styles and you’ll be done with CSS body{
  width:100vw;
  height:100vh;
  box-sizing:border-box;
  font-size:10vh !important;
}
.app{
  width:100%;
  height:100vh;
  display:flex;
  justify-content:center;
  align-items:center;
} Now go to the HTML file. Add React, React Dom, and Babel CDNs to the head of your page then add bootstrap’s CSS-only CDN. Then add a link tag linked to your CSS file. Now add two div elements one with the id of root and one with the id of faceio-modal. Then add a script tag with the type=’text/babel’ to the end of your body and link it to your index.js file. And finally, add fio.js CDN to the end of your body and you’re done. Your HTML file should look like this: <!DOCTYPE html>
<html>

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1">
  <title>FaceIO demo</title>
  <script crossorigin src="https://unpkg.com/react@18.2.0/umd/react.development.js"></script>
  <script crossorigin src="https://unpkg.com/react-dom@18.2.0/umd/react-dom.development.js"></script>
  <script src="https://unpkg.com/@babel/standalone/babel.min.js"></script>
  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/bootstrap@4.4.1/dist/css/bootstrap.min.css" integrity="sha384-Vkoo8x4CGsO3+Hhxv8T/Q5PaXtkKtu6ug5TOeNV6gBiFeWPGFN9MuhOf23Q9Ifjh" crossorigin="anonymous">
<link rel="stylesheet" href='./index.css'>
  
</head>

<body>
<div id='root'></div>
<div id="faceio-modal"></div> 
<script src="https://cdn.faceio.net/fio.js"></script>
<script src="index.js" type='text/babel'></script>
</body>

</html> Now for the JavaScript file, because we have used CDNs we can access react and react Dom as well as faceIO as global variables. The bad thing about using this approach is that you can’t use import statements because we set the type of the index file to text/babel otherwise the code editor will not be able to deal with JSX. But this project is quite easy so we don’t need to make a components folder but for a real-world project just go with npm create-react-app. So we will make use of object destructuring to do what we were supposed to do with imports. Then create an App component. const {createRoot , render} = ReactDOM
const {useEffect,useState}=React Now we need to keep track of users after login so we will create a state for this and to access faceio we will declare a constant io for that const [user,setuser]=React.useState('')
 const io=new faceIO('your public key') Now create 3 helper functions: Logout will set the user to an empty string, register which helps us enroll users in our application. When registering a user you can associate an id to your user, also every user enrolled will have his own id in faceIO databases. The code for the registration function is provided by fio.js API which you can find on the FaceIO website by clicking here . You can adjust the function to match your needs. https://faceio.net/integration-guide function logout(){
    setuser('')
    window.location='./'
  }
  function register(){
    io.enroll({ "locale": "auto", 
    "payload": { UID: Date.now() } }
    ).then(userInfo => {
    alert( `User Successfully Enrolled!
    Details: Unique Facial ID: ${userInfo.facialId}
    Enrollment Date: ${userInfo.timestamp}
    Gender: ${userInfo.details.gender}
    Age Approximation: ${userInfo.details.age}` );
   ;}).catch(errCode => {
   console.log(errCodr) })
  } Now it’s time for the login function. The code for this function is provided by fio.js API and you can adjust it to match your needs. When a user logs in to my app I assigned the user state to the UID of the user to keep track of him. In a bigger app, we can set cookies and much more but for this demo I tried not to complicate things .To learn more about app management click here . https://faceio.net/getting-started function login(){
    io.authenticate({ "locale": "auto" })
    .then(userData => { console.log("Success, user identified") 
                        console.log("Linked facial Id: " + userData.facialId)
                        setuser(userData.payload.UID) })
    .catch(errCode => { console.log(errCode) }) The only thing left to do is to deal with the UI. We need to show the logout button when the user is logged in and the other 2 buttons when the user is not yet logged in. And that’s what this block of code does return(
    <div className='app'>
    {!user? <div><button type="button" className="btn btn-outline-primary m-5" onClick={register} >Register</button>
                 <button type="button" onClick={login} className="btn btn-outline-info m-5">Login</button></div> : 
                 <button type="button" onClick={logout} className="btn btn-outline-primary">Logout</button>}
            </div>) And finally, render the app component to the view. We are using react18, so we will create a root variable and set its value to the div element with ID root. Then we will render the app component. const root = createRoot( document.getElementById('root')); 
root.render(<App/>); And now we’re done coding and it’s time to host this project on GitHub. Simply create a GitHub repository and set its name to . After that upload the files to GitHub and wait 5 minutes till your site is created. And we’re done. myfacerecognition.github.io Conclusion: Face recognition is a great way to authenticate your users in 2022. It still needs a little improvement and that’s what’s going to happen, AI technologies are growing at an exponential rate and that will be reflected in face recognition. Hopefully, this article was helpful in some way, and thank you if you keeping up till this point. In case you’re willing to know more about me visit: . https://houssein.in/ To know more about FACEIO visit : https://faceio.net/

Integrate Face Recognition in Your Web Application in 5 Minutes

Since we launched in 2015,  my co-founding team and I have had the opportunity to help build over 50 MVPs. From first-time founders with early-stage startups to seasoned entrepreneurs with multiple projects under their belts, all in a variety of regions across the globe. Despite the differences in size, location and resources, we’ve noticed that a lot of them made similar mistakes along the way. And while many of the hurdles you will encounter when building an MVP will be specific to you, some are common and easy to avoid. So I sat down with my co-founding team, to combine our 25+ years of experience in building tech startups to identify those common hurdles. The result is a list of 7 mistakes you should avoid before you take your first step to introduce a new product to the market. 1. Focusing on the “Minimum” More Than the “Viable” The purpose of an MVP is not to launch a product before it’s ready. However, many startups will launch a seemingly half-built product into the market, labelling it an MVP. This is a catastrophic mistake that results in a garbage product with an awful user experience. Remember the purpose of building an MVP is to test if your product is viable using as few features as possible. Any product you launch into the world still needs to be technically excellent, with a user experience that will keep people coming back for more. In other words, what’s the simplest way to collect the maximum amount of validated learnings from users while still delivering a high-value experience? Don’t fall into the trap of building a dozen half-assed features, when what you really need is two kick-ass features. 2. Feature Creep a.k.a “Kitchen Sink Syndrome” Feature creep is another dangerous trap many entrepreneurs fall into when building an MVP. This is where the number of features you plan to build spirals out of control. In other words, you throw everything into it, including the kitchen sink! Feature creep can occur for a variety of reasons. Maybe your competitor has a certain feature, so you feel like you must build it. Or perhaps you just “have to” build that cool feature – even though it isn’t necessary to prove your value at the MVP stage. Feature creep is dangerous. It not only increases your costs but also your time to market. A good example of this comes from Instagram’s first iteration, Burbn. Whiskey enthusiast and founder Kevin  Systrom designed the app for fellow whiskey lovers to share their experiences. The app was rich with features, such as the ability to check in and rank whiskey spots. However, many users found the app confusing and adoption was low. Even Systrom himself commented that the app felt “cluttered and overrun with features.” There was one feature, however, that every user adored. The ability to share photos easily with friends. So Systrom made a tough decision: “We went out on a limb, and basically cut everything in the Burbn app except for its photo, comment, and like capabilities. What remained was Instagram.” Systrom listened to the market and built an app with the features needed to show off his value proposition. So, focus on the value, the problem your users have and build an MVP with the fewest features possible to show them that your solution is the best on the market for them. 3. Sacrificing Security & Privacy for a Shorter Time to Market This point is often the result of focusing on the “minimum” and not the “viable” but is important to mention in and of itself. Yes, speed is important when it comes to building an MVP (as I will cover in just a moment). However, you can’t skimp on things like privacy and security in your race to the market. Aside from the obvious moral and ethical issues, it could kill your product, and possibly your startup. Never put your customers at risk – no matter how small that risk may seem. Ensure your MVP is secure and you’ve taken every precaution to protect your users’ privacy before you launch it. 4. Moving Too Slowly As I mentioned in point #3, speed and a short time to market are vital when building an MVP. The longer it takes you to get to market, the higher the chance that your competitors will beat you to the punch. But speed doesn’t just matter when launching your MVP – but when iterating as well. It’s important to take advantage of your agility and ability to pivot quickly as an early-stage startup. It’s something serial entrepreneur Yaron Samid faced first hand when building his fintech startup, BillGuard. I recently had the opportunity to to discuss his startup journey. In the conversation, he shared how the ability to pivot was central to his success. sit down with him His platform was initially designed to be a “set & forget” app that notified fraudulent transactions on your credit card statement. However, with an MVP out in the world, Yaron and his team quickly saw that adoption was low and the CPA was too high. So they pivoted to a B2B model, attempting to sell their anti-fraud technology to the banks. However, as a young startup, they didn’t have the runway for the long sales cycle that comes with selling to large banks. So they had to pivot again: “After two years of investing in a B2B marketing and sales team, with pilots in major banks, we made one of the hardest decisions we had to make. To pivot back to a consumer app. This meant letting go of some amazing talent we had brought in to sell to banks. They just weren’t the right fit for a consumer business model. It was heartbreaking. This time, instead of a security company, we built a personal finance company. We completely redesigned the product. It was no longer a “set & forget” website. It was now a mobile app that would help you identify ways to save money and protect you from fraud. That worked very very well. It grew very quickly.” Yaron took his MVP to the market quickly with a single value proposition in mind, then capitalised on his ability to be agile and pivot to solve the problem his users faced. So, launch your MVP as quickly as possible (while avoiding point #1), learn from the feedback of your users and implement the changes that will improve their experience. 5. Building for Everyone Your product should be designed to solve the problem of a specific user. In other words, your goal isn’t to please everyone. If your value proposition is trying to solve all the problems for the whole world, you risk it being irrelevant for each person. This will ultimately result in a bad user experience and a product with little to no adoption. Instead, your value proposition should be tailored to a smaller group of users who face a specific problem. This is the best way to gather targeted, high-quality feedback that will accurately inform your product roadmap moving forward (your marketing person will thank you too.) A prime example of this is Facebook. Today Facebook is the most active social media platform in the world, boasting around 2.9 billion monthly active users. But when it launched in 2004 its initial audience was exclusively Harvard students. Only when Facebook had gathered enough feedback from that initial group of users did they decide to grow their audience. And even then it was only to Yale and Stanford. It wasn’t until 2006 that Facebook opened its membership to non-students. And they’re not the only famous startup to launch small. Take Slack as another example. The first iteration of Slack was built to solve a very specific problem – the need for a centralised SaaS hub for team communication and file sharing –built for internal use only. It was only after it gained traction among the team that they expanded their audience to other companies. So, build your MVP with a specific group of users in mind and launch solely for them. Gather their feedback, iterate your product and grow your audience gradually. 6. Not Working With the Right Team People are, arguably, the most important aspect of your startup. And having the wrong people building your MVP can be a fatal mistake for your startup. By this I mean, advisors, mentors and, if you’re not a technical founder, technical stakeholders. My co-founder, Daniel, has written an extensive guide on finding the right person to help you build your MVP, but essentially you have three viable options: Find a CTO or technical co-founder Bring on a team of freelance developers Work with a software development company. Finding a CTO/technical co-founder is by far the most idyllic choice. Having that senior technical talent by your side will pay dividends in the long run. However, the issue here is that finding the right CTO/technical co-founder is extremely difficult – especially in an ecosystem where there is a huge shortage of developers. You not only have to find a CTO with the right combination of hard and soft skills for the job, but you also have to convince them to take a bet on your very young startup. It’s the reason so many entrepreneurs are turning to the other two options on the list, freelance developers or a software development company. They all allow you to build your MVP while retaining a short time to market without committing to the huge cost of a full-time CTO. More than this, finding a CTO is often much easier when you have an MVP in the market and have started gaining traction. It’s something Nelly Yusupova, a CTO and startup advisor with nearly 20 years of experience in the tech industry, touched on in a . recent conversation we had She told me that: “Launching your early MVP and gaining traction will really help you attract a technical co-founder because you’ve taken the risk out of that opportunity for them.” Let’s say you hire an agency and they start to build your MVP with a three to five-month timeline. Parallel to that, you’re going to start looking for that technical co-founder or CTO. You’re going to start joining tech communities and building your network. Start to talk to people. And, hopefully, by the time you start having those conversations your MVP is going to have enough traction that it will be a no-brainer for the tech co-founder or CTO to at least consider you.” Finding a technical co-founder is something that myself and my founding team faced before we came together to launch Altar. In fact, it was one of the reasons we built Altar, to begin with. We all struggled to onboard technical co-founders in our previous startups. So, we created Altar to fill the gap in the market and help entrepreneurs build high-quality MVPs within a short time to market. All of this to say, whichever option you choose to help you build your startup, they must be able to produce high-quality code and architecture that follows the industry best practices. At Altar, we’ve worked with entrepreneurs who built their MVP with the wrong team before coming to us. In the worst cases we’ve seen, the code was so poor that we’ve had no choice but to scrap the codebase and start from scratch. Something not every startup can afford to do. 7. Ignoring User Feedback This may seem obvious, but when your users start giving you feedback, listen to it. This often happens when founders are too focused on the solution they want to build, as opposed to the problem they want to solve. Not listening to user feedback will result in you developing a product that nobody wants. This will lead to low adoption rates, barely any traction and it won’t be long before your startup reaches the end of the road. Always remember the why behind building an MVP – to test if the solution you have in mind will actually solve the problem for your target users. The only way to know the results of that test is to listen to the people who are using your MVP. Wrapping Up These are just a handful of the common mistakes people make when building an MVP. The truth is, there are many hurdles to building an MVP, many of which are case-specific. So, my advice to avoid mistakes is to: Define and narrow down your value proposition – What is the problem you intend to solve? And how? Why is this a 10x better way to solve than anything else out there? Build small, but at a high standard – Choose the minimum features possible – while maintaining a meaningful product but also make sure they’re built to a high quality with security and privacy at the core. Only build features that test your value proposition – anything else can wait until you know that people want your product. Don’t take so long to build that you miss your shot – Neither your competitors nor the market will wait for you. Surround yourself with the best talent you can find – Whether they’re in-house or a third party, make sure you’re working with professionals who know their onions. Listen to User Feedback – Remember, your goal is to solve their problem better than anyone else on the market – without them your product can’t succeed. Thanks for reading. Also published here

7 Reasons Why Your MVP may Never Launch

We cannot solve our problems with the same thinking we used to create them -Albert Einstein If you have ever built a Machine Learning model, you've probably felt, Model deployment is a part of Machine Learning which isn't paid as much attention as it should. well, this was cool, but how will other people be able to see how cool it is? Well, in this article, I will introduce you to a new tool that will help you generate a web app for your Machine Learning model, which you can, of course, share with other individuals to try out. I will be building a simple neural network model using scikit-learn (not TF, sorry😒) and creating a GUI for the model using Gradio (this is the new cool tool I spoke about). Let us Begin What is Gradio? According to the , Gradio allows you to quickly create customizable UI components around your TensorFlow or PyTorch models or even arbitrary Python functions. Not terribly informative ei😅. Gradio website If you have ever used a python GUI library like Tkinter, Gradio is like that. Gradio is a GUI library that allows you to create customizable GUI components for your Machine Learning model. Pre-requisite For you to successfully work through this tutorial You must have python installed Let's Get Building You can check out the GitHub repo for the project here Let us begin Install required packages Packages Let us install the required packages pip install sklearn pip install pandas pip install numpy pip install gradio Getting our data Our data is going to be in the. CSV format. You can get the data by clicking here Importing Packages We are going to import the required packages import numpy as np

import pandas as pd

import gradio as gr Next, we are going to filter the warnings so we don't see them. import warnings

warnings.filterwarnings('ignore') Import the data Next, we are going to import our data data = pd.read_csv('diabetes.csv') Now let's see a little preview of our dataset. data.head() Let us see the feature columns in our dataset. print (data.columns) Getting our Variables Next, we get our X and Y variables x = data.drop(['Outcome'], axis=1)

y = data['Outcome'] Splitting the data Now we are going to split our data using the sci-kit-learn's inbuilt function. train_test_split from sklearn.model_selection import train_test_split

x_train, x_test, y_train, y_test = train_test_split(x,y) Scaling our data Next, we are going to scale our data using sci-kit-learn's inbuilt object. StandardScaler from sklearn.preprocessing import StandardScaler

#instantiate StandardScaler object
scaler = StandardScaler()

#scale data
x_train_scaled = scaler.fit_transform(x_train)

x_test_scaled = scaler.fit_transform(x_test) In the code above, we scaled our data using the StandardScaler object made available to us through sci-kit-learn. To know more about Scaling and why it is done, click here Instantiating and training the model In this section, we are going to create and train our model. The model we are going to make us of will be a Multi-Layer Perceptron Classifier, a neural network built into scikit-learn. #import model object
from sklearn.neural_network import MLPClassifier
model =  MLPClassifier(max_iter=1000,  alpha=1)

#train model on training data
model.fit(x_train_scaled, y_train)

#getting model performance on test data
print("accuracy:", model.score(x_test_scaled, y_test)) Creating the function for Gradio Now is the fun part. Here we are going to create a function that will take in the features of the data set which our model was trained on and pass it as an array to our model to predict. Then we are going to build our gradio web app based on that function. To understand why we have to write a function, you must first understand that gradio builds GUI components for our Machine Learning model based on the function. The function provides a way for gradio to get input from users and pass it on to the ML model, which will then process it and then pass it back to gradio, which then passes the result out. Let's Write... First, we will get the feature columns which we will then pass onto our function. #geting our columns

print(data.columns) Now we will create our function. def diabetes(Pregnancies, Glucose, Blood_Pressure, SkinThickness, Insulin, BMI, Diabetes_Pedigree, Age):
#turning the arguments into a numpy array  

 x = np.array([Pregnancies,Glucose,Blood_Pressure,SkinThickness,Insulin,BMI,Diabetes_Pedigree,Age])

  prediction = model.predict(x.reshape(1, -1))

  return prediction In the code above, we passed the feature columns from our data as arguments into a function we named . Then we turned the arguments into a NumPy array which we then passed onto our model for prediction, and finally, we returned the predicted result of our model. diabetes Creating our Gradio Interface Now we are going to create our Web App interface using Gradio. outputs = gr.outputs.Textbox()

app = gr.Interface(fn=diabetes, inputs=['number','number','number','number','number','number','number','number'], outputs=outputs,description="This is a diabetes model") The first thing we did above was to create a variable named outputs, which hold the GUI component for our model result. The result of our model's prediction will be outputted in a text box. Then we instantiated the Gradio interface object and passed in our earlier function. Then we generated our Inputs GUI component, and then we told the radio to expect 8 inputs in form of numbers. diabetes The inputs represent the feature columns that are present in our dataset, the same 8 feature column names we passed into our function. diabetes Then we passed our earlier output variable into the outputs parameter present in the object. Finally, we passed in the description of our web app into the description parameter. Launching the Gradio Web App Now we're going to Launch our Gradio web app. app.launch() If you are launching the Gradio app as a script from that command line, you will be given a local host link that you will copy and paste in our browser to see your web app. NOTE: If you are launching the app from a jupyter notebook, you will see a live preview of the app as you run the cell, and you will also be provided with a link. Hosting and sharing your Web App If you want to share your web app, all you have to do is put in as a parameter in your launch object. share=True #To provide a shareable link
app.launch(share=True) A link will then be provided for you with a .gradio extension. But this shareable link lasts for only 24 hours and will last if only your system is running. Because Gradio just hosts the web app on your system. In simple words, for your link to work, your system has to be on because gradio uses your system to host the web app and once your system is off. The server connection is severed, and you get a 500😅. Luckily for us, Gradio also provides a way for you to permanently host your model. But the service is subscription-based, so you have to pay $7 monthly to access it. Permanent hosting is way out of the scope o this article (partly because the author is broke😅). But if you are interested in it, click . here Important Links Gradio Website Gradio Documentation Gradio on GitHub Summary The Gradio Library is really cool, and it helps solve a huge problem plaguing the Machine Learning Community, Model Deployment. About 90% of Machine Learning models built are not deployed, and Gradio is working to fix that. It also serves as a way for beginners and experts to show off their models and also test the models in real life. You can't go wrong with the Gradio Library. Also Published Here

Build a GUI for Your Machine Learning Models

This post will show you how to build the Feature Toggle mechanism in your Next.JS application. We are going to use Next.JS, React, and TypeScript. We will deploy our application to Vercel to demonstrate a real-life example. You can find the code and video in the summary at the end. What You'll Learn in This Article In this article, we are going to deep dive into several topics such as: What are feature toggles? How to use React's Context API What are environment variables, and how do we use them in our applications? How to build custom hooks in React. What Are Feature Toggles? Feature toggles (aka Feature Flags) are a technique that allows you to change the state of your application without modifying its code. In the beginning, it might sound a bit confusing but let's consider the following scenario: Every December, many companies change their logo to add a bit of holiday spirit. Perhaps they want to add a Santa Claus hat into their logos or some sort of snowman. Have you ever wondered if they change their website every year just to update the logo? No, in most cases, they only do it once, and just connected it into their feature toggle. So they can enable the special logo whenever they need it. Here's another example: imagine a development team that follows continuous integration (CI). They use this mechanism to commit unfinished code, and then merge it onto the main branch. The unfinished code is disabled in the production environment so users cannot see incomplete features. Keep in mind that this is only a good idea for mature development teams that have experienced developers on board along with automated checks for their CI pipelines (like automated tests, static code analysis, compilation / bundling, and so on). Before We Start This tutorial requires some Node and React fundamentals. You should also know how to use Git and GitHub before you follow the instructions in this article. I skipped the part about bootstrapping the example application since I showed a very similar process in one of my previous posts - . How to Build a Fully Functional Serverless App in Under Two Hours I created two GitHub repositories for this post. The first one contains the scaffolder of the application, so you can follow all steps of the tutorial on your own. The second one is the finished application which you can deploy to Vercel without writing any code if you would like just to see the end result. Application Scaffolder (GitHub). The final app, ready to deploy (GitHub). We'll build the example application using Next.JS, React, and Typescript. The main purpose of the application is to display two financial charts. The first one represents the GDP of the United States, and the second one shows Treasury Constant Maturity over the last 10 years. The second one is unfinished. Our goal is to hide it behind the feature toggle, so we can enable it whenever we need it. The final application should look like this: You can find it here. Let's Get Started! We need to clone the scaffolder repository from GitHub, and we can do that by typing the following command in the terminal: $ git clone git@github.com:mateuszsokola/next-feature-toggle-scaffolder.git Now we need install the required dependencies and start the server. $ cd next-feature-toggle-scaffolder
$ npm install
$ npm run dev Now you can open in your browser and see the following website: http://localhost:3000/ Now, how can we implement the Feature Toggle mechanism here? React's Context API seems to be the easiest and most appropriate way. What is the React Context API? The React Context API offers a neat and tidy way of passing data through multiple levels of components without doing it manually. Let's see the following example: <Page enabledFeatures={features} />
<PageLayout enabledFeatures={features} />
<NavigationBar enabledFeatures={features} />
<Link href="https://freecodecamp.org/news/">
  <Avatar enabledFeatures={features} />
</Link> If you don't want to use Context, you will need to pass the data as properties to every component. This is error-prone and cumbersome. If you decide to use the context, you can inject data directly into the component that actually needs it. Now we can create a context for our feature toggle. We need to create a directory called , and a new file inside this directory. We can call it . context/ FeatureToggleContext.ts $ mkdir context
$ cd context
$ touch FeatureToggleContext.ts Creating context in React is fairly easy. You need to import React in your file and call the React.createContext method with the default context value. See the example below: // file: context/FeatureToggleContext.ts
import React from "react";

export const FeatureToggleContext = React.createContext({
  // TypeScript will have hard time to determine its type,
  // if we don't cast this array to an array of strings.
  // Likely, we will end up with an array of never or any.
  enabledFeatures: [] as string[],
}); Have in mind that the default value is only used when the component isn't wrapped into the context provider. It is just a fallback, and it shouldn't be used without the provider. The Context Provider Component Context comes with a Provider component that allows consuming components to listen to context changes. The Provider component takes a value prop that you pass to components that are the children of this provider. In simple words, if we want to take advantage of the context we will need to make the Provider a parent of our all components. I decided to wrap the Provider into a standalone component so we don't clutter up other parts of the application. Let's create a new file in the directory called : components/ FeatureToggle.tsx $ cd components
$ touch FeatureToggle.tsx Now we can create a component that accepts two properties: and . children enabledFeatures The is the main component of the application. If you created a React app using you might have noticed that the main component is called . Next.JS calls it , and you can find it in the file . children create-react-app App MyApp pages/_app.tsx The is the array of enabled features. We will use it later. enabledFeatures # file: compontents/FeatureToggle.tsx

import React from "react";
import { FeatureToggleContext } from "../context/FeatureToggleContext";

type Props = {
    children: any;
    enabledFeatures: string[];
}

export const FeatureToggle = ({ children, enabledFeatures }: Props) => {
    return (
        <FeatureToggleContext.Provider value={{ enabledFeatures }}>
            {children}
        </FeatureToggleContext.Provider>
    )
} The wrapped component is ready. Now we need to hook it into the main component. Let's open the file pages/_app.tsx. We have only one toggleable feature – . We need to add it to the list of enabled features. At the moment, we'll soft code this list, and pass it down directly to the provider to confirm we have access to the context. Later on, we are going to create a proper API for the feature toggle. treasury_chart We need to modify the file to look like this: import { FeatureToggle } from "../components/FeatureToggle";
import "../styles/globals.css";

function MyApp({ Component, pageProps }) {
  const enabledFeatures = ["treasury_chart"];

  return ( 
    <FeatureToggle enabledFeatures={enabledFeatures}>
      <Component {...pageProps} />
    </FeatureToggle>
  );
}

export default MyApp; Technically, the list of enabled features is available in the whole application now. But we have no interface to consume its value. Taking advantage of React hooks is the best way to expose it. How to Create Custom Hooks in React We created this mechanism based on the React Context API, and the most React way to consume React Context is by using hooks. So we will need to create a hook that offers easy access to the right data in the context. Let's create a new directory called , and a new file called . hooks/ useFeatureToggle.ts $ mkdir hooks
$ touch useFeatureToggle.ts Let's think about the hook for a minute. We want to check the status of a given feature. If the feature is enabled we are going to render it, otherwise, we won't. So the hook should return a helper that checks if the requested feature is on the list of enabled features, right? Let's code it. # file: hooks/useFeatureToggle.ts

import React, { useContext } from "react";
import { FeatureToggleContext } from "../context/FeatureToggleContext";

export const useFeatureToggle = () => {
	// we need to read values defined in the FeatureToggleContext. 
    // In this case, we'll take only the array of enabled features.
    const { enabledFeatures } = useContext(FeatureToggleContext);

    const isEnabled = (featureName: string) => {
        return enabledFeatures.includes(featureName);
    }

	// For consistency, We return an array of helpers, 
    // so we follow the pattern defined by the useState hook.
    // It makes the code open for extensions, 
    // so no need to refactor the app when a new helper is added here.
    return [
        isEnabled,
    ];
} The hook is ready. We can open the main page, and connect the Treasury chart into the Feature Toggle. Let's open . pages/index.tsx We are going to use our custom hook to get access to the helper and use it to check if the feature is enabled. isEnabled const [isEnabled] = useFeatureToggle();

// ...

return (
  /* ... /
  {isEnabled("treasury_chart") && (<TreasuryChart />)}
  / ... */
); The complete implementation looks like this: # file: pages/index.tsx

import React from "react";
import Head from "next/head";
import { Layout } from "antd";

import { GdpChart, TreasuryChart } from "../components/Charts";
import { useFeatureToggle } from "../hooks/useFeatureToggle";

const { Header, Content } = Layout;

export default function Home() {
  const [isEnabled] = useFeatureToggle();
  return (
    <Layout className="layout">
      <Head>
        <title>🚦 Feature Toggle in Next.js</title>
      </Head>
      <Header>
        <div className="logo" />
      </Header>
      <Content className="content">
        <GdpChart />
        {isEnabled("treasury_chart") && (<TreasuryChart />)}
      </Content>
    </Layout>
  );
} Now, you can try out the application in your browser. Keep in mind that you will still see the second chart. You can fool around with the feature name given to the helper. For example, you can make a typo, and the chart should disappear afterwards. isEnabled Unfortunately, this solution doesn't give us flexibility to toggle features without modifying the codebase. Every time we want to change the status of the feature, we will need to modify the list of enabled features. How can we fix that? The easiest way to make it toggleable without changing the code would be to implement an API that reads statuses of features from environment variables and returns an array of active features. How to Use Environment Variables in Node An environment variable is a variable whose value is set outside the application, usually by functionality built into the operating system. This is Node.JS, in our case. Let's create a file in our project. .env $ touch .env Now, we can open this file and add a new variable. We can call it . We need to set its value to . FEATURE_TREASURY_CHART false # file: .env

FEATURE_TREASURY_CHART=false If we use .env variables we'll need to use some server features of Next.JS, and define a new API. This means we will need to write more code. So we need to create a new file in the directory. Let's call it . pages/api/ features.ts The API will return an array of enabled features. // file: pages/api/features.ts

export default (req, res) => {
    res.status(200).json([
    	// Your environment variables are available within the `process.env` object.
    	// IMPORTANT! All environment variable values are strings. 
        // So we cannot compare them with booleans, numbers and so on.
        process.env.FEATURE_TREASURY_CHART === "true" ? "treasury_chart" : "",
    ])
} Now, you can try to open in your browser, and you should receive the following output: http://localhost:3000/api/features [""] The wasn't added to the list of enabled features, because it is disabled. You can change the variable to , and restart your server to try it out. treasury_chart FEATURE_TREASURY_CHART true How to Use the Features API We are good to connect the React part of the application to our brand new API. Before we do so, we'll need to install . axios Axios will help us to make HTTP requests in a more convenient way than . It supports error handling and types out of the box. We don't need to implement it on our own, so we can get straight to business. You might need to kill your server by hitting Control + C. Twice. fetch $ npm install --save axios Let's create a new directory called , and a new file called . services/ FeatureToggle.ts Now we need to use a standard asynchronous function to make a GET request to our API. // File: services/FeatureToggle.ts

import axios from "axios";

export const fetchFeatures = async () => {
    try {
        const { data } = await axios.get<string[]>("/api/features");

        return data;
    }
    catch(e) {
        console.log("Something went wrong");
    }

    return [] as string[];
} OK. The feature API request is ready. We can actually trigger this function at the main component. Open the file . pages/_app.tsx We need to make an API request like every other in React using the and hooks. We need to add the following snippet to the component: useEffect useState MyApp const [enabledFeatures, setFeatures] = useState<string[]>([]);

  const processFeatures = async () => {
    const features = await fetchFeatures();

    setFeatures(features);
  }

  useEffect(() => {
    processFeatures();
  }, []); The complete solution is here: // file: pages/_app.tsx

import { useEffect, useState } from "react";
import { FeatureToggle } from "../components/FeatureToggleProvider";
import { fetchFeatures } from "../services/FeatureToggle";
import "../styles/globals.css";

function MyApp({ Component, pageProps }) {
  const [enabledFeatures, setFeatures] = useState<string[]>([]);

  const processFeatures = async () => {
    const features = await fetchFeatures();

    setFeatures(features);
  }

  useEffect(() => {
    processFeatures();
  }, []); // eslint-disable-line react-hooks/exhaustive-deps

  return (
    <FeatureToggle enabledFeatures={enabledFeatures}>
      <Component {...pageProps} />
    </FeatureToggle>
  )
}

export default MyApp; Hurray! We are done with coding. The final step is to deploy our app. How to Publish the App on Vercel We will deploy the application to Vercel, because they offer free hosting for apps and they let us set custom environment variables, which is critical for us. As usual, I am going to skip the process of creating a new account. You can create one with one click using your GitHub or Google account. Once you've signed up, you should see this screen. Click on the "New Project" button: Now you need to select the GitHub repository you want to import. In my case, it is "next-ft-demo", but you might've called it something else. If you don't see your repository, you need to click on "Adjust GitHub App Permission" (the link below marked with the red ellipse): We need to configure the project. Let's open "Environment Variables", add a new variable called FEATURE_TREASURY_CHART, and set its value to false. Then click on the "Add" button, and hit "Deploy": The application is being deployed now. You should see the following screen once done. Just click on the "Go To Dashboard" button: You can open your application by clicking the "Visit" button: The application displays only one chart: If you want to enable the Treasury chart you need to select the "Settings" tab, choose the "Environment variables" section, and set the FEATURE_TREASURY_CHART variable to true: Now we need to redeploy the application to load new variables. Once the deployment is completed you will see the Treasury chart on your website: Summary This is a simple implementation of Feature Toggles. You'll probably need to adjust it to fit your needs. But I think it's a good starting point that you can build upon. If you have an idea about how to improve my solution or you want to show us yet another way of doing it, please share it in the comment section of the YouTube video below (I reply to every comment). WATCH VIDEO ON YOUTUBE HERE If you find the video useful it would mean the world to me if you smash the like button and subscribe. You can find all the code on GitHub: Application Scaffolder (GitHub). The final app, ready to deploy (GitHub). If you have any questions you can DM me on Twitter: @msokola I hope you liked it and have a great day :) Also published on: https://www.freecodecamp.org/news/how-to-use-feature-toggles-in-next-js-and-react/

An Essential Guide to Feature Toggles Using Next.JS and React

The Diffusion of Responsibility Phenomenon Analyzed: Unravel the Truth

Artificial intelligence (AI) is the field of making computers able to act intelligently, to make decisions in real environments that will have favorable outcomes. This is obviously a broad, and somewhat vague, definition, and there are many fields within this umbrella term. One example of such a field is that of computer vision, in which computers can process images as a human would, and make inferences about what is in an image so that computer programs can then use that information to make decisions that have favorable outcomes. It is becoming more common to see artificial intelligence applications such as computer vision integrated into new business models and products. Computer vision has many real-world applications, analyzing traffic patterns, detecting changes in posture, counting the number of persons in an area, etc. Learning how to build any computer vision application requires a steep learning curve, and deploying it to the edge adds an extra layer of complication. While deploying and running applications in the cloud has become more popular in recent years, this isn’t always the best solution, especially for applications that require heavy processing or that use sensitive data, both of which are often the case with computer vision applications. In such circumstances, the best option is often to deploy your application to the edge. Deploying computer vision applications on the edge has numerous benefits, which we will go through in this article. We will also describe the challenges of running computer vision on the edge and how to overcome them. What is ‘the edge’? In general, edge devices are small, lightweight, devices on which a computer vision application can be deployed and run. Many edge devices today even have a Graphical Processing Unit (GPU), or Visual Processing Unit (VPU), which enable usage of a greater range of models and application complexity. In the context of this article, an edge device is a device such as a Raspberry Pi, NVIDIA Jetson devices like the Jetson Nano or NVIDIA Jetson Xavier NX, or various Internet of Things (Iot) devices, which are edge devices that have some capability to sense or assess, and possibly interact with, the environment in which they are used. Benefits of Running Computer Vision on the Edge The three main benefits of running a computer vision application on the edge are time, security, and cost. 1. Reduced Latency While an internet connection can be used to deploy the application, once the application is on the edge device, there is no need for it to have cloud connectivity to function. This means that any inferencing the application does is on the edge device itself, not in the cloud, and this drastically reduces the time it takes for those inferences to be turned into actions by the application. For certain use cases, such as self-driving vehicles or security cameras, this is imperative. Aside from the risk that data may be lost being sent to and from the cloud, the additional time required for using a cloud approach can mean not responding to a task in time, which can be catastrophic for tasks like autonomous driving. There are also specialized peripheral devices, in particular cameras, that don’t have internet connectivity themselves and are used by edge devices to improve performance or expand application functionality. Such devices take the concept of processing on the edge even further. Instead of a USB or ribbon camera transmitting the image data to an edge device for processing, these devices incorporate a processor into the camera itself, further reducing processing latency. 2. Improved Security Secondly, because the data doesn’t need to travel to the cloud with edge deployment, all data can stay in a closed circuit on the device itself. Edge computing distributes the risk of exposure across multiple devices, and can perform all processing disconnected form a central server - a more secure and private architecture. For example, edge devices can be installed inside of a person’s home, process real-time data and act on that data without relying on a shared cloud service that could compromise the privacy of their day-to-day activity. Because computer vision data may involve people or other sensitive data, this is much more secure. 3. Reduced cost Finally, without the need for cloud processing, deploying a CV application on the edge is much less expensive, as cloud companies charge for inferencing per endpoint per minute. This is a great, flexible option for those who want to pay on an ‘as needed’ basis, but becomes burdensome for organizations that demand large amounts of real-time processing - such as a smart city, hospital or warehouse with many cameras and sensors running 24 hours a day. Challenges of Running Computer Vision on the Edge Building a computer vision application entails its own challenges, and is often an iterative process, and therefore any pipeline you use to build computer vision applications must be flexible enough to handle changes such as the model or libraries used, or device that the application is deployed on. Let’s walk through the challenges of deploying computer vision applications on the edge with a story. First, you need to get a computer vision model, either by 1) scouring the web for an open-source model that fits your needs, or 2) by building an image dataset and t The second option requires collecting your own dataset, which is labor-intensive, as well as an understanding of several tools for image annotation and the training itself. raining your own model. Next, you need to build your application. Let’s say you have a working model and you are prototyping your computer vision application. One popular computer vision library is OpenCV. Developers can easily use the C++ or Python Application Programming Interfaces (APIs) of OpenCV. For example, developers can access the Python OpenCV API simply by using . You spend some time learning this API and have a working prototype that integrates well with the output of your model. pip install opencv-python Now that you’re happy with the app, you’d like to deploy it to an edge device, like a Raspberry Pi. The first thing you’ll find is that the OpenCV build you were using isn’t compatible with the Raspberry Pi processor. Other dependencies may also have the same problem. This leads you to compile OpenCV on the Raspberry Pi. Next, you need to figure out how to see the results! On your laptop, this was easy with cv2.imshow(), but if you’re working on a headless device (no graphical interface), you’ll need to find another way. Now that your app is up and running, you see that the amazingly fast performance you saw on your laptop is long gone. Of course, nobody expects a $35 single-board computer to outperform your Macbook, but you want better performance. You’ve read that you can use Intel’s Neural Compute Stick 2 to get better performance out of a Pi, but now you need to build OpenVINO as well. Since OpenVINO’s interface is different from OpenCV, you’ll need to decide whether to rewrite your app to take advantage of the NCS2, or rebuild OpenCV so it can run the OpenVINO inference engine. When it’s all said and done, you may find that your model requires more tweaking, possibly the output changes, and you may be looping through the steps again! How to Overcome These Challenges Overcoming these challenges requires IoT experience in addition to computer vision knowledge. However, a developer platform such as can also help solve these problems. At alwaysAI, we have the singular mission of making the process of building and deploying computer vision apps to edge devices as easy as possible. That includes training your model, building your app, and deploying your app to edge devices such as the Raspberry Pi, Jetson Nano, and many others. alwaysAI Once you have installed alwaysAI, you only need to know a few basic commands, our command line interface (CLI) to collect data, annotate it, train a model, and deploy and start your applications. Obtaining a Computer Vision Model alwaysAI has a catalog of that are guaranteed to work with any application built with our pipeline. You can also train your own object detection model using the alwaysAI , which is built using TensorFlow as the backend framework and does transfer learning on mobilnet_ssd, which was trained on the COCO dataset. publicly available models model training toolkit The model training toolkit enables users to start working with TensorFlow without learning a new API or installing any extra modules by hand. We also include the Computer Vision Annotation Tool (CVAT) as part of the toolkit, so users can annotate new datasets without needing to download and install CVAT from scratch. Developing your Application We have our own Python API, called edgeiq, which wraps some of OpenCV’s core functionality and which can be used to interact with. This means you only need to know one API to get up and running with computer vision applications. Since we ourselves love to use OpenCV, we’ve built it in as a core piece of our edge runtime environment, which means you can add `import cv2` to every alwaysAI application and use OpenCV directly in your app, regardless of your choice of deployment device. Deploying your Application We leverage containerization via Docker images and Python virtual environments, and this makes deploying your application simple no matter what your device is. This also makes it easy to add any necessary requirements your application may need, using either the Dockerfile or requirements.txt files. Running computer vision on the edge saves both time and cost, and has the additional benefit of being more secure. While developing and deploying any computer vision application comes with its own set of challenges, this can be especially true when deploying on the edge. Our main goal at alwaysAI is to overcome these challenges and make developing and deploying computer vision applications on the edge as easy as possible for users. You can ! try our platform yourself for free

The Challenges of Running Computer Vision on the Edge

My Thoughts on Stocktwits, Censorship, and Online Harassment

Continuous Integration/Delivery (CI/CD) is one of the most obvious candidates for moving to a Kubernetes cluster, as you automatically enjoy all the benefits of Kubernetes scalability. In traditional CI solutions, companies employ a fixed set of build nodes that teams must manually monitor and upgrade. By moving your CI/CD pipelines to Kubernetes and containers you gain two important advantages: You can now dynamically manage your build tools (i.e. Node, Python, Maven) in Docker images instead of installing them by hand on build nodes. Your builds scale automatically as you run more pipelines without any manual configuration. Kubernetes autoscaling is working to your advantage, dynamically allocating resources according to build usage. While most organizations are employing Kubernetes clusters only in order to deploy their production workloads, Kubernetes clusters are actually ideal for your “supporting” services such as artifact management, continuous integration, security scanning, etc. In fact, if you haven’t switched to Kubernetes and microservices already, using a cluster for supporting the software lifecycle might prove valuable if you don’t want to tamper with your production applications that are still running in Virtual Machines. There are many solutions for running pipelines in a Kubernetes cluster. In this article, we will see how you can use the open-source Codefresh Runner. How does the runner work The Codefresh Runner can be found in Github at . It is part of the Codefresh CLI (that includes additional capabilities for managing existing pipelines and builds). The runner is a native Kubernetes application. You install it on your cluster and then it takes care of all aspects of pipeline launching, running, cleaning up, etc. If you have auto-scaling enabled on your Kubernetes the runner will automatically scale as your run more pipelines. You can install the runner on any compliant Kubernetes distribution. The cluster can be public or private (even behind a firewall). In fact, the Codefresh Runner can even be installed on your local Kubernetes cluster if you have one on your workstation. For example, you can easily install the Codefresh runner on your Kubernetes distribution for a quick demo. It is important to mention that the Codefresh runner does not need any incoming traffic (it only fetches build information). This means that you don’t need to open any firewall ports or tamper with your NAT settings if you choose to install the Runner on a private Kubernetes cluster. For more information on the Codefresh Runner see its . https://github.com/codefresh-io/cli Docker-for-Deskop documentation page Prerequisites To install the Runner and start running pipelines on your cluster you will need: A terminal with access to your cluster. You can use any of the popular cloud solutions such as Google, Azure, AWS, Digital Ocean, etc, or even a local cluster such as Microk8s, Minikube, K3s, etc. kubectl in order to access the management UI for the Runner. A free account with Codefresh For the installation, you can also use the “cloud console” of your cloud provider. If you run any command (such as ) and get a valid response, then you are good to go. kubectl kubectl get nodes the Codefresh CLI and . You can create an API token from your Codefresh account by visiting . Download/Install authenticate it https://g.codefresh.io/user/settings Once you have the token you can use it on the command line: { codefresh auth create-context --api-key API_KEY} That’s it for the authentication portion. Quick start with the installation wizard The Codefresh Runner has multiple installation methods, but the simplest one is by using the command-line wizard. To start the wizard execute: codefresh runner init You will be asked a series of questions (where in most cases you can simply accept the defaults). The installation wizard will then take care of everything. It will install the runner components in your cluster and setup authentication with the Codefresh UI. Verifying the installation of the runner By default, the quick start wizard will also create a sample pipeline and provide the URL to visit to see it running in the Codefresh UI. If everything works ok, you will see the message “hello codefresh runner” in the build console. You can also inspect the status of the runner components using standard Kubernetes tools. By default, all components of the runner are in the “codefresh” namespace. kostis@ubuntu18-desktop:~$ kubectl get pods -n codefresh
NAME                                              READY   STATUS    RESTARTS   AGE
dind-5ef0a18bd2f8f459f2d32c78                     1/1     Running   0          37s
dind-lv-monitor-runner-7pnf2                      1/1     Running   0          4d22h
dind-lv-monitor-runner-lf746                      1/1     Running   0          4d22h
dind-lv-monitor-runner-xc8lp                      1/1     Running   0          4d22h
dind-volume-provisioner-runner-64994bbb84-fsr6x   1/1     Running   0          4d22h
engine-5ef0a18bd2f8f459f2d32c78                   1/1     Running   0          37s
monitor-697dd5db6f-72s6g                          1/1     Running   0          4d22h
runner-5d549f8bc5-pf9mw                           1/1     Running   0          4d22h Some of the components are permanent and some will be launched dynamically only when pipelines are actually running. Creating your own pipeline With the demo pipeline running up and running, it is now time to create your own pipeline. Pipelines and are composed . are described in YAML of different steps You can edit the YAML definition directly in the Codefresh UI, or just store it in a Git repository (the same one that holds your application or a different one). Here is a very simple pipeline with 3 steps: First, we check out the code with a clone step Then we and push it to a registry build a Docker image Finally, we deploy it to a cluster using Helm And here is the pipeline definition: version: '1.0' stages: - prepare - build - deploy steps: clone: title: Cloning main repository... stage: prepare type: git-clone arguments: repo: codefresh-contrib/helm-sample-app revision: master git: github build: title: Building Docker Image stage: build type: build working_directory: ./helm-sample-app arguments: image_name: helm-sample-app-go tag: multi-stage dockerfile: Dockerfile deploy: title: Deploying Helm Chart type: helm stage: deploy working_directory: ./helm-sample-app arguments: action: install chart_name: charts/helm-example release_name: my-go-chart-prod helm_version: 3.0 .2 kube_context: my-demo-k8s-cluster custom_values: - 'buildID=$ ' {{CF_BUILD_ID}} - 'image_pullPolicy=Always' - 'image_tag=multi-stage' - 'replicaCount=3' - 'image_pullSecret=codefresh-generated-r.cfcr.io-cfcr-default' You can find a more detailed explanation in the . You should also check your pipeline settings and make sure that it is assigned to the cluster that has your runner (because it is possible to have multiple runners in multiple clusters). Helm example This means that you can assign a specific pipeline to use a specific runner. Connecting to your private services One of the advantages of the Codefresh runner is easy access to your internal services without compromising security. The runner can connect to Git repositories, Docker registries, Kubernetes clusters, and other resources that are also behind the firewall. To enable these services to be used in pipelines you need to visit the integrations screen at . https://g.codefresh.io/account-admin/account-conf/integration Here you can centrally set up the configuration of each resource. Each resource will then get a unique name/identifier that you can use in your YAML pipelines. For example, you can add multiple internal/external registries: In the example above, I have 3 registries connected to the runner. Now I can simply mention them in the pipeline by name. version: '1.0' steps: BuildMyImage: title: Building My Docker image type: build image_name: my-app-image dockerfile: my-custom.Dockerfile tag: 1.0 .1 registry: dockerhub This build step will build a custom Dockerfile, tag the image as , and then push the image to Dockerhub. my-app-image:1.0.1 Notice the complete lack of Docker login/tag/push commands. They are all abstracted away and your pipeline is as simple as possible. You can follow the same pattern with the other integrations (e.g. Kubernetes clusters and Helm charts). Notice that the Kubernetes cluster that is hosting the runner is also available by name so you can deploy applications to it in a declarative way. For more information on YAML pipelines check the . You can also using . example directory write your own pipeline steps plain Docker images Enjoy! Cover photo by Unsplash at https://unsplash.com/photos/AxW7QCCqLCE Previously published at https://dev.to/kostiscodefresh/run-ci-cd-pipelines-behind-your-firewall-with-the-codefresh-runner-5457

How To Build CI/CD Pipelines Behind Your Firewall Using Codefresh Runner 

The Best 75 Evernote Alternatives:  Complete Review

Think you know how you’re spending time? I’m not sure. Do you often panic if you haven’t finished a task on time or just don’t have enough energy left? This issue often goes unaddressed as many prefer to just hide the dirt under the rug and show their wins instead. We often brag about what we’ve achieved, but how many of us have the courage to talk about our work efficiency problems? The first step to find a solution, though, is admitting you’ve got a problem. Gif source Ask yourself: Do I know how I’m spending my time? reveals that the majority of surveyed people spent time checking their personal email inboxes, browsing the Internet, and shopping online as well. This Salary.com study A whopping 25% of respondents visit Amazon.com regularly. And employers don’t even know it. If you thought that younger employees were more likely to slack off, you’ll be surprised to find that 67% of employees with doctorate degrees do it too. For this reason, more companies are creating stricter social media policies to help workers increase their productivity levels. The problem is not just for the workplace though. Just think about how much time you’re actually wasting checking your phone, Facebook wall, Twitter feed, or email inbox hundreds of times a day outside of the office. Every day. But all these rules won’t make you stop doing it. So how do you make this fun? There is this one method that can help you stop wasting time and keep your productivity level top notch: time tracking. I know... it might sound complicated and you’re dead serious about not using yet another productivity tool. But, to be honest, you’ve probably done it before. When was that? This morning when you checked your alarm clock to get to work on time or during your commute when you calculated if you still had enough time to grab your favorite latte. Doesn’t feel like a chore, right? That’s because time tracking is just a way to keep your daily activities in check. Fortunately, there are a few time-saving shortcuts that will make you to see where your time is going. WANT How do I choose a productivity tool that suits my needs? The first step is to always think of your main requirements. Knowing why and how you’re going to use a tool can also show whether you really need to get one or not. Are you a freelancer who’s looking to create estimates and get paid fairly, a remote worker who has to provide proof of their work, or maybe you just want to get more done? One productivity tool might suit your personal needs but it could not be advanced enough to handle employee monitoring in a work environment. Similarly, employees could feel hesitant to use a time tracking tool that takes occasional screenshots of their desktops or photos of them. Such software has no purpose if you’d just like to improve your daily efficiency because no one else will evaluate your progress. Then, you need to assess the main functionalities you’ll be using. Here are 5 of the ones you should really consider: Reporting and analysis Do you have any proof of your wasted time? Productivity and time tracking tools can offer real stats on how much you’re working (or slacking) and where your time is going. These can even be used to create future time estimates. Just go back to check your activity reports, see how much time it took you to finish a task, and you’ll be able to create an accurate estimate of how long it’ll take to complete a similar duty. An all-in-one solution As mentioned before, a solid advantage of using a complete productivity tool is that you no longer have to switch between apps to track time individually for each website or software you use. As a bonus, these tools often include other useful features such as task management, calendars, accounting modules, collaboration boards, and more. You’re pretty much getting your satisfied on one single platform, eliminating the necessity of switching between apps to find your required information. Integration with other tools One of the most important things you should look for is making sure that your choice suits the devices and tools you’re already working with. Migrating data from one tool to another can be burdensome and costly. Check which devices work with the tool (e.g. PC, Android, iOS, etc.) and look for any other integrations. For instance, you might want to connect it to one of your cloud storage providers (Dropbox, Google Drive, OneDrive). If you’re looking to pair it with other tools, you can either check out customized integrations or use a connector tool like or . These usually have quick built-in integrations for most tools out there. You can even get them to turn your lights on once you get home or light the way for when the pizza delivery guy arrives. Zapier IFTTT File management The good news is that there are productivity tools that allow you to store your documents within them. Generally, these also have task and project management features to help you organize all your activities. You’ll no longer get lost if one teammate sends you a photo via Skype, another one in Slack, and the rest to your email inbox. Everything will now be in one place. Reduced usage time Nobody wants to get a tool just to find out that using it is taking up even more time. Make sure you’re not wasting any time while actually using a tool that’s supposed to help you get your day back. Your tool choice should be easy to use and take you just a few seconds to make an action. This equals in more results, higher-quality outcomes, and less time spent on non-productive activities. Don’t forget about the tool’s cost. Paying for a productivity tool just to check how much time you spent in an app once a year might not be the best deal. Don’t worry. Most tools offer a free trial so you can take them for a spin without committing financially. Note: What tools and methods can I use? Frankly, the tools you’re already using to boost your productivity might be draining too much of your time instead of saving it. Whether it’s a lengthy Slack conversation over your colleague’s new car or a few hours you spend each day checking your email, these are still time-consuming activities. Here’s where time tracking comes in. Most productivity tools are useless without it. Having a look into what software you’re using the most is not enough if you’re not aware of how much time you’re allocating for them. , for instance, is an app that helps people cure their smartphone addiction by tracking how much time they spend in an app and blocking the time-wasting ones. Just leave it to run in the background for 2 weeks and you’ll get a fairly accurate report of your stats. AntiSocial Moving on to your desktop, the Chrome extension adds up the minutes, hours, and days (yes, days) you’ve spent watching funny videos or music videos on YouTube. In this way, you’ll get a better look at your viewing habits. YouTube Watch Time Counter Want to finally find out how much of your day you’ve wasted aimlessly scrolling Facebook? They recently introduced a that allows you to see the amount of time you spend on Facebook (Instagram too) each day. You can also set reminders to notify you when you reach your daily limit. mobile app feature Now, you might already be using one or more productivity tools. But there’s also a way that can help you avoid losing time while switching between these apps: using only one tool to rule (track) them all. Tools like allow you to check how much time you’ve spent in a day, week, month or year according to each one of your projects, tasks, or clients. It records everything you do on your computer including desktop programs, file management, Internet browser activity, and idle time. PaymoPlus Key Takeaways Now the lack of productivity problem has been around for a while. You might remember the Microsoft Solitaire era. Still, there’s no miraculous solution that works for everyone. Whether you want to become a better worker or you’ve set a New Year’s goal for yourself, avoid obsessing over maintaining control over your time. Having a break every once in a while can actually be more beneficial. Take a moment to sit back and relax. This will help you focus better on your work and give your best. As one final piece of advice, don’t expect your peak performance levels to stay the same forever. You’re sometimes going to find yourself working slower or being less creative than the previous day. Gif source This doesn’t mean you have to waste time on social media or funny cat videos. Instead, try productive procrastination such as cleaning your workspace or making yourself a cup of coffee to help you unwind and get back to your duties. Now, do you really know how you’re spending your time? Let us know and share your own tips for becoming more aware of how you’re distributing time daily, what has worked for you, and what hasn’t.

You Don't Know What You're Spending Your Time On Unless You Start Tracking It

Is Your Smartphone a Hacker’s Hub? Smartphones are your on the go everything, from financial transactions to professional communications to entertainment — reasons why smartphones have become a frequent target for hackers, even more so than computers. Your smartphone could be hacked and you might not be aware of. Security researchers are witnessing a significant shift in hackers behavior and their evolving taste in the smartphone community. Of course, at this point your smartphone has more information about you, more than you think. At any given time your phone knows your whereabouts, who you might be talking to, all your banking app passwords, your email, your personal pictures and what not. All this data in one place makes the smartphone an Aladdin’s magic lamp for exploiters. A research conducted by Check Point concluded that . It is speculated that hackers have gained access to more than 1.3 million Google accounts; including personal documents, photos, emails and more. over 1 million smartphones are affected How Vulnerable is Your Smartphone Android is the most used operating system in the world, and second largest OS in general, it requires around 12 million lines of coding to create the Android OS. This complexity gives space to bugs to get through even after multiple checking. These bugs can further be exploited to manipulate your smartphone and what data you store. Most recently, a critical bug that let hackers load spyware without user’s permission. A user would receive a WhatsApp call from an unknown source, and regardless of whether the user answers it or not, their phone is taken over by the exploiters. They install spyware that bypasses Google security check for all the application and turns on the phone’s camera or microphone to carry our harmful activities. WhatsApp discovered A lot of people are into customization; they’d download a third-party modded app without knowing the . Just like any other app or official app, modded apps, too require specific permission to access camera, location, storage and others. Meaning you could be handing over your smartphone to a complete stranger and letting them access whatever they want. dangers involved Another vulnerability in smartphone comes from accessing unsecure sites. Earlier this year in February, hackers seeded unsecure websites with malware. The malware was an image through a code that was in .PNG format. If a user chose to download the file and open it, the code would execute automatically, giving all-out access to hackers. hidden inside Andrew Blaich, a researcher for Lookout, and Eva Galperin, EFF’s cybersecurity director, together presented their findings on a malware campaign that was running on a global level targeting smartphones. , the malware had affected thousands of users in over 20 countries. The attackers target smartphone community using official look-alike apps and getting them installed. Once the app was installed, it would gain root access to the phone, giving complete control to the hackers. According to their study Galperin says, “Getting a look into someone’s personal device is tremendously personal, it’s like getting a look into their mind.” Missing Out on Firmware Updates Not every smartphone receive frequent updates. If the market trends say anything, phones older than years are open to more security risks. The has left millions of smartphone open to cyber attacks. Moreover, older smartphone users tend to download the modded app way more compared to the latest smartphone. The limitation of firmware restricts new trending app to work on predated android versions. Some OEM cut support to even their latest smartphones, even after google’s wholehearted support. frightful side of Android upgrade program Although the developer community do try to help by introducing custom ROM and firmware. That too isn’t safe as the device requires rooted access. How Can you Stay Protected — Since the advent of GDPR, consumer rights have strengthened. Users now can request their data deletion if they don’t feel secure vendor with their personal information. Know Your Rights — It is advisable not to load apps outside the genuine source as they may contain malicious elements. You may have to adjust a bit on the customization or visual grounds, but you’ll have proper security. Don’t Use Third-Party Apps — no matter how tempting or click bait-ish an ad appears, refrain from clicking it. Often the popups and ads are coded with the virus that could freeze the complete system and trick users into installing a malicious app that does more damage than good. Never Click Suspicious Ads or Pop Ups — Updating the firmware or security patch isn’t something users can do by themselves, rolling update lies with the smartphone manufacturer, so as soon as there’s a notification of firmware update, do it. Same is with the apps you are using. New version brings bug fixes and bridges any vulnerability in the app, by , you minimize any risk. Keep Your Firmware Up to Date updating — The .PNG malware also targeted people through email. A user would receive a mail with an image attachment, and as soon as the user opens it, the code executes and takes over the smartphone. Avoid Opening Unwanted Emails or Messages — If one day you find an app in your app drawer that wasn’t there before and you have no recollection of installing such app, delete it immediately. If the app is still there a day later, establish a powerful antivirus like Malwarebytes and give your smartphone a thorough scan. If the problem persists, do the hard reset. Hard Reset — There are tons of VPN out there, but not all of them provide measured anonymity. You can research a bit and with a premium plan and surf the web without having to expose your personal information. Use of Good VPN download VPN Conclusion Security breaches are getting worse, and smartphones are now more at risk than ever. Zurich Insurance Group and a think tank of Atlantic council online industry would expand the global economy by 8 %, however, the expenditure on security and managing the safe business will outweigh the benefits by a large margin. reported This report shines a light on the dark side of technology eclipsing all in range. You can always take caution to stay a hands distance from danger and if you chose to download apps from the third party, do it from reputed stores.

Stories, News & Mentions about APPWAY

Appway’s Stories on HackerNoon