One place for hosting & domains

      How To Run Transactions in Redis


      Introduction

      Redis is an open-source, in-memory key-value data store. Redis allows you to plan a sequence of commands and run them one after another, a procedure known as a transaction. Each transaction is treated as an uninterrupted and isolated operation, which ensures data integrity. Clients cannot run commands while a transaction block is being executed

      This tutorial goes over how to execute and cancel transactions, and also includes some information on pitfalls commonly associated with transactions.

      How To Use This Guide
      This guide is written as a cheat sheet with self-contained examples. We encourage you to jump to any section that is relevant to the task you’re trying to complete.

      The commands shown in this guide were tested on an Ubuntu 18.04 server running Redis version 4.0.9. To obtain a similar setup, you can follow Step 1 of our guide on How To Install and Secure Redis on Ubuntu 18.04. We will demonstrate how these commands behave by running them with redis-cli, the Redis command line interface. Note that if you’re using a different Redis interface — Redli, for example — the exact output of certain commands may differ.

      Alternatively, you could provision a managed Redis database instance to test these commands, but note that depending on the level of control allowed by your database provider, some commands in this guide may not work as described. To provision a DigitalOcean Managed Database, follow our Managed Databases product documentation. Then, you must either install Redli or set up a TLS tunnel in order to connect to the Managed Database over TLS.

      Running Transactions

      The multi command tells Redis to begin a transaction block. Any subsequent commands will be queued up until you run an exec command, which will execute them.

      The following commands form a single transaction block. The first command initiates the transaction, the second sets a key holding a string with the value of 1, the third increases the value by 1, the fourth increases its value by 40, the fifth returns the current value of the string, and the last one executes the transaction block:

      • multi
      • set key_MeaningOfLife 1
      • incr key_MeaningOfLife
      • incrby key_MeaningOfLife 40
      • get key_MeaningOfLife
      • exec

      After running multi, redis-cli will respond to each of the following commands with QUEUED. After you run the exec command, it will show the output of each of those commands individually:

      Output

      1) OK 2) (integer) 2 3) (integer) 42 4) "42"

      Commands included in a transaction block are run sequentially in the order they’re queued. Redis transactions are atomic, meaning that either every command in a transaction block is processed (meaning that it’s accepted as valid and queued to be executed) or none are. However, even if a command is successfully queued, it may still produce an error when executed. In such cases, the other commands in the transaction can still run, but Redis will skip the error-causing command. See the section on understanding transaction errors for more details.

      Canceling Transactions

      To cancel a transaction, run the discard command. This prevents any previously-queued commands from running:

      • multi
      • set key_A 146
      • incrby key_A 10
      • discard

      Output

      OK

      The discard command returns the connection to a normal state, which tells Redis to run single commands as usual. You’ll need to run multi again to tell the server you’re starting another transaction.

      Understanding Transaction Errors

      Some commands may be impossible to queue, such as commands with syntax errors. If you attempt to queue a syntactically incorrect command Redis will return an error.

      The following transaction createst a key named key_A and then attempts to increment it by 10. However, a spelling error in the incrby command causes and error and closes the transaction:

      • multi
      • set key_A 146
      • incrbuy key_A 10

      Output

      (error) ERR unknown command 'incrbuy'

      If you try to run an exec command after trying to queue a command with a syntax error like this one, you will receive another error message telling you that the transaction was discarded:

      Output

      (error) EXECABORT Transaction discarded because of previous errors.

      In cases like this, you’ll need to restart the transaction block and make sure you enter each command correctly.

      Some impossible commands are possible to queue, such as running incr on a key containing only a string. Because such command is syntactically correct, Redis won’t return an error if you try to include it in a transaction and won’t prevent you from running exec. In cases like this, all other commands in the queue will be executed, but the impossible command will return an error:

      • multi
      • set key_A 146
      • incrby key_A "ten"
      • exec

      Output

      1) OK 2) (error) ERR value is not an integer or out of range

      For more information on how Redis handles errors inside transactions, see the official documentation on the subject.

      Conclusion

      This guide details a number of commands used to create, run, and cancel transactions in Redis. If there are other related commands, arguments, or procedures you’d like to see outlined in this guide, please ask or make suggestions in the comments below.

      For more information on Redis commands, see our tutorial series on How to Manage a Redis Database.



      Source link

      How To Write and Run Your First Program in Node.js


      The author selected the Open Internet/Free Speech Fund to receive a donation as part of the Write for DOnations program.

      Introduction

      Node.js is a popular open-source runtime environment that can execute JavaScript outside of the browser using the V8 JavaScript engine, which is the same engine used to power the Google Chrome web browser’s JavaScript execution. The Node runtime is commonly used to create command line tools and web servers.

      Learning Node.js will allow you to write your front-end code and your back-end code in the same language. Using JavaScript throughout your entire stack can help reduce time for context switching, and libraries are more easily shared between your back-end server and front-end projects.

      Also, thanks to its support for asynchronous execution, Node.js excels at I/O-intensive tasks, which is what makes it so suitable for the web. Real-time applications, like video streaming, or applications that continuously send and receive data, can run more efficiently when written in Node.js.

      In this tutorial you’ll create your first program with the Node.js runtime. You’ll be introduced to a few Node-specific concepts and build your way up to create a program that helps users inspect environment variables on their system. To do this, you’ll learn how to output strings to the console, receive input from the user, and access environment variables.

      Prerequisites

      To complete this tutorial, you will need:

      Step 1 — Outputting to the Console

      To write a “Hello, World!” program, open up a command line text editor such as nano and create a new file:

      With the text editor opened, enter the following code:

      hello.js

      console.log("Hello World");
      

      The console object in Node.js provides simple methods to write to stdout, stderr, or to any other Node.js stream, which in most cases is the command line. The log method prints to the stdout stream, so you can see it in your console.

      In the context of Node.js, streams are objects that can either receive data, like the stdout stream, or objects that can output data, like a network socket or a file. In the case of the stdout and stderr streams, any data sent to them will then be shown in the console. One of the great things about streams is that they're easily redirected, in which case you can redirect the output of your program to a file, for example.

      Save and exit nano by pressing CTRL+X, when prompted to save the file, press Y. Now your program is ready to run.

      Step 2 — Running the Program

      To run this program, use the node command as follows:

      The hello.js program will execute and display the following output:

      Output

      Hello World

      The Node.js interpreter read the file and executed console.log("Hello World"); by calling the log method of the global console object. The string "Hello World" was passed as an argument to the log function.

      Although quotation marks are necessary in the code to indicate that the text is a string, they are not printed to the screen.

      Having confirmed that the program works, let's make it more interactive.

      Step 3 — Receiving User Input via Command Line Arguments

      Every time you run the Node.js “Hello, World!” program, it produces the same output. In order to make the program more dynamic, let's get input from the user and display it on the screen.

      Command line tools often accept various arguments that modify their behavior. For example, running node with the --version argument prints the installed version instead of running the interpreter. In this step, you will make your code accept user input via command line arguments.

      Create a new file arguments.js with nano:

      Enter the following code:

      arguments.js

      console.log(process.argv);
      

      The process object is a global Node.js object that contains functions and data all related to the currently running Node.js process. The argv property is an array of strings containing all the command line arguments given to a program.

      Save and exit nano by typing CTRL+X, when prompted to save the file, press Y.

      Now when you run this program, you provide a command line argument like this:

      • node arguments.js hello world

      The output looks like the following:

      Output

      [ '/usr/bin/node', '/home/sammy/first-program/arguments.js', 'hello', 'world' ]

      The first argument in the process.argv array is always the location of the Node.js binary that is running the program. The second argument is always the location of the file being run. The remaining arguments are what the user entered, in this case: hello and world.

      We are mostly interested in the arguments that the user entered, not the default ones that Node.js provides. Open the arguments.js file for editing:

      Change console.log(process.arg); to the following:

      arguments.js

      console.log(process.argv.slice(2));
      

      Because argv is an array, you can use JavaScript's built-in slice method that returns a selection of elements. When you provide the slice function with 2 as its argument, you get all the elements of argv that comes after its second element; that is, the arguments the user entered.

      Re-run the program with the node command and the same arguments as last time:

      • node arguments.js hello world

      Now, the output looks like this:

      Output

      [ 'hello', 'world' ]

      Now that you can collect input from the user, let's collect input from the program's environment.

      Step 4 — Accessing Environment Variables

      Environment variables are key-value data stored outside of a program and provided by the OS. They are typically set by the system or user and are available to all running processes for configuration or state purposes. You can use Node's process object to access them.

      Use nano to create a new file environment.js:

      Add the following code:

      environment.js

      console.log(process.env);
      

      The env object stores all the environment variables that are available when Node.js is running the program.

      Save and exit like before, and run the environment.js file with the node command.

      Upon running the program, you should see output similar to the following:

      Output

      { SHELL: '/bin/bash', SESSION_MANAGER: 'local/digitalocean:@/tmp/.ICE-unix/1003,unix/digitalocean:/tmp/.ICE-unix/1003', COLORTERM: 'truecolor', SSH_AUTH_SOCK: '/run/user/1000/keyring/ssh', XMODIFIERS: '@im=ibus', DESKTOP_SESSION: 'ubuntu', SSH_AGENT_PID: '1150', PWD: '/home/sammy/first-program', LOGNAME: 'sammy', GPG_AGENT_INFO: '/run/user/1000/gnupg/S.gpg-agent:0:1', GJS_DEBUG_TOPICS: 'JS ERROR;JS LOG', WINDOWPATH: '2', HOME: '/home/sammy', USERNAME: 'sammy', IM_CONFIG_PHASE: '2', LANG: 'en_US.UTF-8', VTE_VERSION: '5601', CLUTTER_IM_MODULE: 'xim', GJS_DEBUG_OUTPUT: 'stderr', LESSCLOSE: '/usr/bin/lesspipe %s %s', TERM: 'xterm-256color', LESSOPEN: '| /usr/bin/lesspipe %s', USER: 'sammy', DISPLAY: ':0', SHLVL: '1', PATH: '/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin:/sbin:/bin:/usr/games:/usr/local/games:/snap/bin', DBUS_SESSION_BUS_ADDRESS: 'unix:path=/run/user/1000/bus', _: '/usr/bin/node', OLDPWD: '/home/sammy' }

      Keep in mind that many of the environment variables you see are dependent on the configuration and settings of your system, and your output may look substantially different than what you see here. Rather than viewing a long list of environment variables, you might want to retrieve a specific one.

      Step 5 — Accessing a Specified Environment Variable

      In this step you'll view environment variables and their values using the global process.env object and print their values to the console.

      The process.env object is a simple mapping between environment variable names and their values stored as strings. Like all objects in JavaScript, you access an individual property by referencing its name in square brackets.

      Open the environment.js file for editing:

      Change console.log(process.env); to:

      environment.js

      console.log(process.env["HOME"]);
      

      Save the file and exit. Now run the environment.js program:

      The output now looks like this:

      Output

      /home/sammy

      Instead of printing the entire object, you now only print the HOME property of process.env, which stores the value of the $HOME environment variable.

      Again, keep in mind that the output from this code will likely be different than what you see here because it is specific to your system. Now that you can specify the environment variable to retrieve, you can enhance your program by asking the user for the variable they want to see.

      Step 6 — Retrieving An Argument in Response to User Input

      Next, you'll use the ability to read command line arguments and environment variables to create a command line utility that prints the value of an environment variable to the screen.

      Use nano to create a new file echo.js:

      Add the following code:

      echo.js

      const args = process.argv.slice(2);
      console.log(process.env[args[0]]);
      

      The first line of echo.js stores all the command line arguments that the user provided into a constant variable called args. The second line prints the environment variable stored in the first element of args; that is, the first command line argument the user provided.

      Save and exit nano, then run the program as follows:

      Now, the output would be:

      Output

      /home/sammy

      The argument HOME was saved to the args array, which was then used to find its value in the environment via the process.env object.

      At this point you can now access the value of any environment variable on your system. To verify this, try viewing the following variables: PWD, USER, PATH.

      Retrieving single variables is good, but letting the user specify how many variables they want would be better.

      Step 7 — Viewing Multiple Environment Variables

      Currently, the application can only inspect one environment variable at a time. It would be useful if we could accept multiple command line arguments and get their corresponding value in the environment. Use nano to edit echo.js:

      Edit the file so that it has the following code instead:

      echo.js

      const args = process.argv.slice(2);
      
      args.forEach(arg => {
        console.log(process.env[arg]);
      });
      

      The forEach method is a standard JavaScript method on all array objects. It accepts a callback function that is used as it iterates over every element of the array. You use forEach on the args array, providing it a callback function that prints the current argument's value in the environment.

      Save and exit the file. Now re-run the program with two arguments:

      You would see the following output:

      Output

      /home/sammy /home/sammy/first-program

      The forEach function ensures that every command line argument in the args array is printed.

      Now you have a way to retrieve the variables the user asks for, but we still need to handle the case where the user enters bad data.

      Step 8 — Handling Undefined Input

      To see what happens if you give the program an argument that is not a valid environment variable, run the following:

      • node echo.js HOME PWD NOT_DEFINED

      The output will look similar to the following:

      Output

      /home/sammy /home/sammy/first-program undefined

      The first two lines print as expected, and the last line only has undefined. In JavaScript, an undefined value means that a variable or property has not been assigned a value. Because NOT_DEFINED is not a valid environment variable, it is shown as undefined.

      It would be more helpful to a user to see an error message if their command line argument was not found in the environment.

      Open echo.js for editing:

      Edit echo.js so that it has the following code:

      echo.js

      const args = process.argv.slice(2);
      
      args.forEach(arg => {
        let envVar = process.env[arg];
        if (envVar === undefined) {
          console.error(`Could not find "${arg}" in environment`);
        } else {
          console.log(envVar);
        }
      });
      

      Here, you have modified the callback function provided to forEach to do the following things:

      1. Get the command line argument's value in the environment and store it in a variable envVar.
      2. Check if the value of envVar is undefined.
      3. If the envVar is undefined, then we print a helpful message indicating that it could not be found.
      4. If an environment variable was found, we print its value.

      Note: The console.error function prints a message to the screen via the stderr stream, whereas console.log prints to the screen via the stdout stream. When you run this program via the command line, you won't notice the difference between the stdout and stderr streams, but it is good practice to print errors via the stderr stream so that they can be easier identified and processed by other programs, which can tell the difference.

      Now run the following command once more:

      • node echo.js HOME PWD NOT_DEFINED

      This time the output will be:

      Output

      /home/sammy /home/sammy/first-program Could not find "NOT_DEFINED" in environment

      Now when you provide a command line argument that's not an environment variable, you get a clear error message stating so.

      Conclusion

      Your first program displayed "Hello World" to the screen, and now you have written a Node.js command line utility that reads user arguments to display environment variables.

      If you want to take this further, you can change the behavior of this program even more. For example, you may want to validate the command line arguments before you print. If an argument is undefined, you can return an error, and the user will only get output if all arguments are valid environment variables.



      Source link

      Run a Small Business? Here are 8 Ways to Manage Your Stress


      There are plenty of perks to owning your business — like being the boss, for one. You get to see your own plans and dreams come to life. And you can set the company track exactly as you see fit. But the downside to running a small business? All of the stress that comes with it. That’s why learning to manage stress is crucial for small biz owners.

      “Managing stress is important as a business owner because typically, we tend to be sole proprietors or have few employees,” says Amanda Pratt MSW, LCSW, CPLC, The Chronic Illness Therapist, Imagine Life Therapy. “This means that if we burn out, it can ultimately slow business progress or momentum and when we aren’t well, our businesses can’t be well. We also know that if we cope poorly with stress, we tend to have worse physical and mental health outcomes overall, so business owner or not, this is an area that I feel should be a top priority for all of us.”

      Reducing stress should always be at the top of your to-do list to keep you sane — and your company healthy, too. “That’s why it’s important not to feel guilty for stepping back or prioritizing some ‘me’ time,” says Poppy Greenwood, mental health advocate, serial entrepreneur and co-founder of female entrepreneur support platform Meyvnn.

      Luckily, there are plenty of small business stress management techniques that will help take away the tension and anxiety of your work. Give these tactics a try to manage your stress levels.

      8 Ways to Handle Small Biz Stress

      Stressed small business owner.

      1. Recognize What’s Going Well

      “This is one of the first things I will point out to clients — it’s just as important to recognize what’s going well (if not more so) as it is to recognize where things aren’t going so well,” Pratt says.

      “Strategies that work best for us tend to play off our strengths. It’s also good to take inventory of areas of coping where we tend to have more engaged or active responses to stress (versus disengaged responses) and can inform our future attempts at other areas of stress management. We all have habits that come more naturally to us that are healthy, and I believe these are the strategies we should tap into first to address when creating a stress management plan.”

      Plus, when you consider what’s going right with your business, that instantly puts you in a positive mindset, which makes it much easier to combat stress. “Taking stock of things that have gone well helps you put into perspective the change you are affecting and the growth that you have achieved,” Greenwood says. “Feeling that you’re making progress, no matter how small, is one of the best ways to relax. It helps you to recognize you’re on a journey, and that your work towards whatever goal you have is pushing you forwards.

      “It also just makes you feel more organized,” Greenwood says. “Being able to identify where things are working or are not makes you feel like you have control over what is happening, in what can feel like the chaos of running a business.”

      Focusing on the good things about your business also keeps your mind in the present. “When you’re stressed, your brain tells you that you have to stay vigilant,” says Drema Dial, Ph.D., psychologist and life coach. “Your brain goes into hyperdrive with all the things that could be going wrong, will go wrong, might have already gone wrong, and how will you fix it! This is one way our brain uses to keep us locked into familiar routines. This is precisely why it’s imperative to break this cycle, which keeps us chained to unhealthy coping behaviors and keeps your stress level high.”

      2. Identify Your Stressors

      “Identifying your stressors is vital to be able to tackle them,” Greenwood says. “Stress usually comes from a problem you haven’t yet started to solve or are having trouble solving. I think the best way to identify stressors is to take a step back. When you’re an entrepreneur, you’re constantly working and adjusting and testing to grow. Being in that kind of intense mindset all day long can really constrict a wider perspective you need to really pinpoint the areas that are causing you stress and how best to tackle them. Once you’ve identified what is causing you stress, you are much more able to work out how to deal with it. And even just identifying what is causing you stress can help alleviate some of it.”

      Remember that people respond to stress in their own unique way. “Self-awareness is key here because everyone is different,” says Mike McDonnell, international speaker, serial entrepreneur, global brand co-owner and podcaster. Once you know what stresses you out, you can delegate those tasks to others. If that’s not an option, knowing that a particular part of the job triggers anxiety can help you prepare to tackle it and just take a deep breath before going in. Over time, you can work on changing your response to the stressor.

      “We can do this through practicing mindfulness techniques to open our awareness to our body sensations, thoughts, and behaviors,” Pratt says. “We can also self-monitor through journaling or tracking mood states, symptoms and thought habits. And while it’s good to identify stressors, it’s even more important to identify our perceptions and responses to these stressors. Research shows us that it matters less what the stressor is and more how we respond to the stressor.”

      3. Build a Solid Schedule

      “Structure is important because the more we plan, the less we have to actively anticipate what might happen,” Pratt says. “Planning helps us have a greater sense of self-efficacy or confidence in our ability to handle whatever might come up.”

      When you have a regular routine, you know what to expect at work, and that gives you a sense of peace and control, making it easier to keep stress at bay. If you know in advance that you have a difficult item to cross off your to-do list, tackle it first thing in the morning to avoid that sense of dread. Plus, you’ll feel accomplished and ready to conquer whatever else comes your way.

      “Your body also likes a routine — it’s good for your circadian rhythm, which is effectively your internal body clock that can dictate things like when you feel tired or energized and can really impact your ability to focus,” Greenwood says. “For example, I know my energy and concentration dip around 3 p.m. So, in my routine around that time, I usually have a workout scheduled that gives me some time away to re-energize.”

      A common complaint from small business owners is that there are never enough hours in the day. “Usually when we delve into this issue, the problem is not a lack of time but a lack of a schedule,” Dial says. “A schedule allows a person to plan, to anticipate, and helps keep life organized. I recommend that all activities go onto a schedule, even play time!”

      4. Prioritize Your Time

      There’s a reason “self-care” has become such a buzzword — we’ve come to realize just how crucial it is to carve out time for ourselves to keep a healthy mental state. Looking after yourself is key to keeping stress under control.

      “Prioritizing ‘me time’ is really important because it is so easy to get caught up in what you’re doing, you can really forget about yourself and who you are — separate from your business,” Greenwood says. “Taking time for yourself, or using it to go out with friends and family, is often what re-affirms your belief in what you’re doing. It’s really important to not lose yourself within your business, because that, in the worst case scenario, then can lead to your business itself losing its way.”

      As a small business owner, it’s all too easy to fall into the trap of always being on the clock. Just as you schedule time for certain tasks you need to get done, you should schedule free time. “I teach clients to see their downtime as beneficial to creativity and efficiency because they tend to work better after taking a break,” Dial says. “Taking a break allows the brain to take in new information and to generate creativity.”

      5. Learn to Say ‘No’

      “When you’re starting out, you may not have the luxury of opportunities flying at you, so you say yes to everything,” McDonnell says. “But eventually you focus on your mission and ask yourself, ‘Will this help me get there?’ before deciding yes or no.”

      Of course, saying no can be really tough. But it’s important to remember your value and that you have limited time. “Instead of thinking you may offend the other person, it’s an opportunity to show them that when you decide to do something, you really value what you’re doing and you’re doing it on your terms,” Greenwood says.

      Otherwise, taking on more than you can handle is the fastest way to fall into a stress trap. “It’s important to learn that setting boundaries is necessary to safeguard small business owners’ well-being, their time, and to protect their business,” Dial says. “When approached with a request, the small business owner should ask themselves the following: ‘1. Is this something I want to do? 2. Do I have time to do it? 3. What is its importance level, and will it fit it into my schedule?’”

      Saying no is also key to setting boundaries. “When we don’t set boundaries, we end up feeling taken advantage of, burned out, stressed out, and end up as people pleasers, workaholics, isolated, or feeling misunderstood,” Pratt says. “Simply stated: Boundaries are one of the best things you can do for your physical and mental health and wellness.”

      6.Delegate or Outsource Tasks

      When you’re used to being the boss, it can be hard to let go and give up control. But as any small business owner knows, you can’t do it all. And if you’re trying to, then you’re probably not doing a good job at every single thing. That’s why learning how to delegate or outsource certain parts of the biz is a foundation for being successful.

      For example, do you struggle with Facebook but love working face-to-face with clients? Hiring a social media manager might free you up to do just that. Figure out how you want to spend your time — and what you’d rather avoid.

      In the end, outsourcing allows you to grow your company. “It’s important early on to recognize where your weaknesses are, so that you can hand over those areas to other people who do them much better,” Greenwood says. “Doing this can also relieve so much stress, not having a task hang over you that you know you need to do but that you struggle with and find time-consuming.”

      7. Choose Your Tools Wisely

      Work tools and software are meant to make your job easier — not harder. But if you’re spending more time learning how to use them than actually using them, it’s not doing you any favors. “It’s important to choose tools wisely, because they are meant to be the things that take away stress and help with tasks instead of adding to the problem,” Greenwood says.

      Opting for reliable small business appsweb management tools, and hosting services will always pay off in the end. Imagine if your business’ website went down? That’s why it’s worth using DreamHost hosting and WordPress to have one less thing to worry about.

      “Test out different software until you find the one that takes your stress away so you can benefit fully from it,” McDonnell says.

      Shared Hosting That Powers Your Purpose

      We make sure your website is fast, secure and always up so your visitors trust you.

      8. Unplug During Your Off-time

      “You’re not a robot,” Greenwood says. “You can’t work all the time and expect to maintain the same level of productivity and efficiency. You need to replenish your energy levels, and not just physically but mentally, emotionally, and spiritually. When you’re working on your business, you want to be present and in the moment. That would be difficult if you’re unable to unplug in your off time and feel a conflict between your work life and your personal life.”

      As a small business owner, you probably feel tied to your phone, but you need time away from answering emails and checking in with customers. “Unplugging and doing a digital detox allows parts of your brain to rest,” Dial says. “Reading, watching TV, going for a walk, and talking with others are all great ways to engage a different part of your brain. Make sure you take time for activities you find enjoyable. It’s essential to combat stress by seeking out experiences that will help restore you.”

      It’s especially important to power down your devices and avoid blue light, which can keep you awake, at least an hour before bedtime. Plus, you won’t have to worry about an email keeping you up that night. You’ll sleep better so you can be rested and alert for the next day of tending to your business.

      Breathe In and Out

      It’s no secret that running a small business is one of the most challenging (and stressful) things you’ll ever take on. But it’s also one of the most rewarding! So tell us: how do you manage your stress as a small-biz owner? What keeps you fired up as you “Rise and Grind?” Connect with us on Twitter and let us know your thoughts!





      Source link