One place for hosting & domains

      How to Write Product Descriptions That Really Sell: 8 Simple Tips


      Congratulations! You’ve done the hard marketing work to lead your target customer right to your product pages. They are currently reading through a product description to decide whether or not they will purchase something from your e-commerce business.

      The million dollar question: will they buy what you’re selling?

      The answer, in large part, depends on how much time and effort you put into your product description. It may seem drastic to weigh product descriptions so heavily, but stats show that a well-written product description is a surefire conversion tool. Here’s a closer look:

      • 87% of consumers ranked product content extremely or very important when deciding to buy.
      • Millennials are 40% more likely than other adults to say product content is extremely important to their purchasing decisions.
      • Consumers purchasing clothing and online groceries ranked product descriptions as the second most influential factor in their decision to buy — just after price.
      • 20% of purchase failures are potentially a result of missing or unclear product information.

      The stats don’t lie. If you want to increase sales, it’s time to polish your e-commerce product descriptions.

      Shared Hosting to Power Your Purpose

      We make sure your website is fast, secure, and always up so your visitors trust you. Plans start at $2.59/mo.

      8 Ways to Write an Excellent Product Description

      But what actually makes a good product description? In this guide, we’re giving you eight tips (along with winning examples) that provide a comprehensive look into what makes an effective product description. Let’s go!

      1. Identify Your Buyer Personas

      It can be difficult to write a product description if you don’t know who your target audience is. To successfully write about product features that resonate with your potential buyers, you have to know who they are.

      This means you need to reference your buyer persona(s)  — a fictional representation of your ideal customer based on market research. If you don’t already have a buyer persona to guide the copywriting on your website, the time to create one is now.

      A buyer persona should answer all of the following general questions:

      • What is the demographic information of your buyers?
      • What are their interests?
      • What is their native language?
      • What kind of language appeals to them? (e.g., Does industry jargon appeal to them or turn them off?)
      • How do they spend their free time?
      • How do they find your website?
      • Why are they interested in your store?

      If you have the luxury of big data at your hands, collect data on your current customers to also understand:

      • Product preferences
      • Behavioral patterns
      • Purchasing patterns

      Access to this data will help you fine-tune your buyer personas. Once you know who you are selling to, it will be easier to write product descriptions that resonate well with them.

      2. Focus on Product Benefits and Features

      As crucial as it is to speak the language of your buyers, your buyers don’t come to your page to connect. They come to learn precisely what your product can do and how it will meet their needs and fulfill their pain points. To accomplish this, you need to write an extensive list of your product’s features and benefits.

      Start with the features. For example, if you sell shoes, include size information, material, color information, the weight of the shoe, etc. Your features section should be comprehensive and tell consumers everything they need to know about what makes your product special.A list of features is a great start, but it’s only half the battle. Potential customers also want to know the benefits of your particular product. And, this is where your product description can shine.

      With the shoe example, benefits would include things like comfort, flexibility, odor-resistance, wet and dry traction, etc.

      Allbirds does a fantastic job showing off the benefits of their shoe without being verbose. Their advantages are spelled out in short, sweet blurbs that get right to the point.

      Allbirds product benefits.
      Allbirds clearly identifies its products’ main benefits for customers.

      Benefits are your main selling points, your differentiators, and the reasons why customers will end up selecting your product over your competitors. Don’t neglect clearly identifying them.

      3. Stay True to Your Brand’s Voice

      If your brand’s voice is professional, your product descriptions should be professional. If your brand is snarky and sarcastic, then your product descriptions should match. Is your brand funny? Be funny when writing your product descriptions.

      Everyone is familiar with the hilarious Poo-Pourri advertising videos. You know, the videos that took Poo-Pourri from a $10 million company to a $30 million company almost overnight?

      Poo-Pourri has a unique brand identity and tone of voice, which they stay true to even when describing their products.

      Poo-Pourri product description.
      Poo-Pourri stays true to their brand’s unique voice in product descriptions.

      4. Tell a Full Story

      Every good story has a beginning, a middle, and an end. Unless, of course, you’re one of the writers on Game of Thrones, but I digress.

      With product descriptions, the formula for good writing is no different. You need to present a complete story that engages your readers. This doesn’t mean you need to write a novel, but at the same time, your product description shouldn’t just be a list of features and benefits either.

      Instead, show (not tell) your customers how the product will improve their lives. Help them visualize a real-life scenario where your product solves a problem. The goal is to create a narrative arc in which the reader is the hero and your product is the tool that enables them to succeed.

      For example, check out the impressive product storytelling of Malicious Women Candle Co.

      Customers aren’t just buying a candle at Malicious Women Candle Company. They are purchasing a product that promotes empowerment with a side of hustle and energy. Now that’s a product story.

      5. Use Active Language to Persuade Buyers

      Your mom was right; the words you use make a difference — especially with product descriptions. The truth is that some words are just more persuasive than others. In fact, experts have roadtested all kinds of language to come up with 189 words and phrases that actually improve conversion rates.

      Consider these 20 tried-and-tested words recommended by David Ogilvy, the proverbially ‘Father of Advertising’:

      • Suddenly
      • Now
      • Announcing
      • Introducing
      • Improvement
      • Amazing
      • Sensational
      • Remarkable
      • Revolutionary
      • Startling
      • Miracle
      • Magic
      • Offer
      • Quick
      • Easy
      • Wanted
      • Challenge
      • Compare
      • Bargain
      • Hurry

      The common theme? Persuasive words encourage consumers to take action.

      Jon Morrow of SmartBlogger.com has his own list of 600 power words that will tap into your customer’s emotions, making them more likely to engage with your message.

      Sample of Jon Morrow’s 600-word list
      Sample of Jon Morrow’s 600-word list

      Since many companies use awe-inspiring (see what we did there?) power words in their product descriptions, it’s easy to find good examples — even for seemingly bland products. Here’s one about shaving cream from Ulta Beauty.

      Ulta Beauty product description.
      Ulta Beauty utilizes power words to make shaving cream seem swanky.

      When writing product descriptions, take a moment to scan through your copy and make sure each word is pulling its weight.

      6. Make Text Scannable with Bullet Points

      Making your text scannable is one of the most critical elements of writing a good product description. Studies suggest humans have an attention span that’s shorter than that of a goldfish — a bleak eight seconds.

      This means it’s essential to make your content easily digestible. The solution to packing a narrative punch in a relatively small space? Create a bulleted list.

      J. Crew does this well. Customers can click on a picture to see the item of interest and quickly read the scannable bullet points for more information.

      J. Crew product description with bullet points.
      Bullet points make it easy for J. Crew customers to scan the fine print.

      The more you can do to make a product description scannable, the better.

      7. Optimize Copy for Search Engines

      Copywriters have a unique challenge when it comes to writing product descriptions. They must persuade readers, but there’s another audience to keep in mind too: search engine algorithms.

      Search Engine Optimization (SEO) — including identifying and using the appropriate keywords for your products — should be a critical part of your product description writing process.

      The SEO world is constantly changing, along with Google’s algorithms, so what works one day might not be ideal the next. However, there are still some keyword strategies that stand the test of time, such as avoiding duplicate content and including keywords in the following places:

      • Page title
      • Product title
      • Meta descriptions
      • Alt tags
      • Product descriptions

      The keywords you use in your copy help Google and other search engines identify what the page is about. This information then used to determine how to rank your site on the search engine results page (SERP) so that relevant results to served up to people imputing related search queries.

      For example, when you type “shaving cream” into Google, Google offers a list of products.

      Google search result for 'shaving cream'.
      Google displays popular products when you search for ‘shaving cream.’

      There are literally hundreds of shaving cream products on the market today, but these five products have the best SEO keyword strategy.

      Take Cremo Shave Cream, for example. When visiting their product page, it’s clear they have maximized the use of keywords, such as shave cream and shave.

      Cremo product descriptions focused on keywords.
      Cremo focused on incorporating keywords into its product descriptions.

      Additionally, when you check out the page source, you can see the back-end (e.g., alt tags) are optimized with the keyword as well.

      8. Add Images and Video

      It should go without saying that a great product description must include images. If you need extra persuasion, remember that 63% of consumers believe good images are more important than product descriptions.

      If your e-commerce store can afford to hire a product photographer, awesome! If not, there are lots of DIY product photography tutorials to help get you started. Of course, good photos start with good equipment, including:

      • Camera
      • Tripod
      • Nice background
      • White bounce cards made of foam board
      • Table
      • Tape

      Once you’ve gathered your gear, you’ll need some tips on how to actually take stellar photos. This guide from Bigcommerce provides beginner-friendly tips at budget-price: how to shoot exceptional product photos for under $50. Suggestions include:

      • Using a light-colored backdrop so it’s easier to touch up images.
      • Creating your own lightbox to distribute light evenly.
      • Using a tripod to steady your camera.
      • Retouching images before posting them.

      If you don’t think a smartphone will do the trick, think again. All you need for affirmation is to take a gander at some of the DIY photographers on Instagram. Jennifer Steinkop of @aloeandglow, for example, uses an iPhone 8 Plus, the Lightbox app, and some of the tips mentioned above to create gorgeous beauty shots.

      @aloeandglow Instagram account
      @aloeandglow Instagram account

      Looking for a more corporate example? iRobot has excellent product photography on its website. The company includes at least four images and often a video (bonus!) to show consumers exactly how the product works.

      iRobot’s Roomba i7 product page.
      iRobot’s Roomba i7 product page.

      With a few clicks of a button in a second or two, consumers know exactly what they are getting when they buy a Roomba.

      Another tip courtesy of iRobot: consider adding customer reviews to your product description. In addition to quality imagery, social proof can be hugely motivating for prospective buyers.

      Be Awesome on the Internet

      Join our monthly newsletter for tips and tricks to build your dream website!

      How to Create a Product Description Template

      While we’ve just outlined eight tips for writing product descriptions that really sell, it’s important to note that there is no one-size-fits-all solution. That’s because all products have different features, benefits, and selling points.

      However, if you have a list of similar products and you don’t want to start from scratch every time you write a product description, it can be beneficial to create a template.

      There are lots of handy product description template examples you can download from e-commerce websites. To really maximize their value, though, we’d recommended you focus on the 8 tips we outlined above. Start by asking:

      • What are your buyer personas?
      • What are the pain points of your customers?
      • How does your product solve customer pain points?
      • What power words can you use in your copy?
      • Do you have a unique story or brand voice?
      • Is your language accessible and free of industry jargon?
      • What are the main features and benefits of your products?
      • Do you have an image and video library?

      Once you’ve answered these questions, you can tweak your template and test it with your audience. If you find a specific template is outperforming others, then you’ve found your winner.

      Your Products, Our Hosting

      Ready to revolutionize the way you write product descriptions and how you display them on your website? At DreamHost, we offer low-cost shared WordPress hosting, and a variety of other resources to help you build the perfect custom website for your online store. Check out our shared hosting plans today!





      Source link

      How To Write Your First Program in Go


      Introduction

      The “Hello, World!” program is a classic and time-honored tradition in computer programming. It’s a simple and complete first program for beginners, and it’s a good way to make sure your environment is properly configured.

      This tutorial will walk you through creating this program in Go. However, to make the program more interesting, you’ll modify the traditional “Hello, World!” program so that it asks the user for their name. You’ll then use the name in the greeting. When you’re done with the tutorial, you’ll have a program that looks like this when you run it:

      Output

      Please enter your name. Sammy Hello, Sammy! I'm Go!

      Prerequisites

      Before you begin this tutorial, you will need a local Go development environment set up on your computer. You can set this up by following one of these tutorials:

      Step 1 — Writing the Basic “Hello, World!” Program

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

      Once the text file opens up in the terminal window, you’ll type out your program:

      hello.go

      package main
      
      import "fmt"
      
      func main() {
        fmt.Println("Hello, World!")
      }
      

      Let’s break down the different components of the code.

      package is a Go keyword that defines which code bundle this file belongs to. There can be only one package per folder, and each .go file has to declare the same package name at the top of its file. In this example, the code belongs to the main package.

      import is a Go keyword that tells the Go compiler which other packages you want to use in this file. Here you import the fmt package that comes with the standard library. The fmt package provides formatting and printing functions that can be useful when developing.

      fmt.Println is a Go function, found in the fmt package, that tells the computer to print some text to the screen.

      You follow the fmt.Println function by a sequence of characters, like "Hello, World!", enclosed in quotation marks. Any characters that are inside of quotation marks are called a string. The fmt.Println function will print this string to the screen when the program runs.

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

      Now you can try your program.

      Step 2 — Running a Go Program

      With your “Hello, World!” program written, you're ready to run the program. You’ll use the go command, followed by the name of the file you just created.

      The program will execute and display this output:

      Output

      Hello, World!

      Let's explore what actually happened.

      Go programs need to compile before they run. When you call go run with the name of a file, in this case hello.go, the go command will compile the application and then run the resulting binary. For programs written in compiled programming languages, a compiler will take the code from a program and generate another type of lower-level code (such as source code or machine code) to produce an executable program.

      Go applications require a main package and exactly one main() function that serves as the entry point for the application. The main function takes no arguments and returns no values. Instead it tells the Go compiler that the package should be compiled as an executable package.

      Once compiled, the code executes by entering the main() function in the main package. It executes the line fmt.Println("Hello, World!") by calling the fmt.Println function. The string value of Hello, World! is then passed to the function. In this example, the string Hello, World! is also called an argument since it is a value that is passed to a method.

      The quotes that are on either side of Hello, World! are not printed to the screen because you use them to tell Go where your string begins and ends.

      In this step, you've created a working "Hello, World!" program with Go. In the next step, you will explore how to make the program more interactive.

      Step 3 — Prompting for User Input

      Every time you run your program, it produces the same output. In this step, you can add to your program to prompt the user for their name. You'll then use their name in the output.

      Instead of modifying your existing program, create a new program called greeting.go with the nano editor:

      First, add this code, which prompts the user to enter their name:

      greeting.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
        fmt.Println("Please enter your name.")
      }
      

      Once again, you use the fmt.Println function to print some text to the screen.

      Now add the highlighted line to store the user's input:

      greeting.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
        fmt.Println("Please enter your name.")
        var name string
      }
      

      The var name string line will create a new variable using the var keyword. You name the variable name, and it will be of type string.

      Then, add the highlighted line to capture the user's input:

      greeting.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
        fmt.Println("Please enter your name.")
        var name string
        fmt.Scanln(&name)
      }
      

      The fmt.Scanln method tells the computer to wait for input from the keyboard ending with a new line or (n), character. This pauses the program, allowing the user to enter any text they want. The program will continue when the user presses the ENTER key on their keyboard. All of the keystrokes, including the ENTER keystroke, are then captured and converted to a string of characters.

      You want to use those characters in your program's output, so you save those characters by writing them into the string variable called name. Go stores that string in your computer's memory until the program finishes running.

      Finally, add the following highlighted line in your program to print the output:

      greeting.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
        fmt.Println("Please enter your name.")
        var name string
        fmt.Scanln(&name)
        fmt.Printf("Hi, %s! I'm Go!", name)
      }
      

      This time, instead of using the fmt.Println method again, you're using fmt.Printf. The fmt.Printf function takes a string, and using special printing verbs, (%s), it injects the value of name into the string. You do this because Go does not support string interpolation, which would let you take the value assigned to a variable and place it inside of a string.

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

      Now run the program. You'll be prompted for your name, so enter it and press ENTER. The output might not be exactly what you expect:

      Output

      Please enter your name. Sammy Hi, Sammy ! I'm Go!

      Instead of Hi, Sammy! I'm Go!, there's a line break right after the name.

      The program captured all of our keystrokes, including the ENTER key that we pressed to tell the program to continue. In a string, pressing the ENTER key creates a special character that creates a new line. The program's output is doing exactly what you told it to do; it's displaying the text you entered, including that new line. It's not what you expected the output to be, but you can fix it with additional functions.

      Open the greeting.go file in your editor:

      Locate this line in your program:

      greeting.go

      ...
      fmt.Scanln(&name)
      ...
      

      Add the following line right after it:

      greeting.go

      name = strings.TrimSpace(name)
      

      This uses the TrimSpace function, from Go's standard library strings package, on the string that you captured with fmt.Scanln. The strings.TrimSpace function removes any space characters, including new lines, from the start and end of a string. In this case, it removes the newline character at the end of the string created when you pressed ENTER.

      To use the strings package you need to import it at the top of the program.

      Locate these lines in your program:

      greeting.go

      import (
          "fmt"
      )
      

      Add the following line to import the strings package:

      greeting.go

      import (
          "fmt"
        "strings"
      )
      

      Your program will now contain the following:

      greeting.go

      package main
      
      import (
              "fmt"
              "strings"
      )
      
      func main() {
          fmt.Println("Please enter your name.")
          var name string
          fmt.Scanln(&name)
          fmt.Printf("Hi, %s! I'm Go!", name)
          name = strings.TrimSpace(name)
      }
      

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

      Run the program again:

      This time, after you enter your name and press ENTER, you get the expected output:

      Output

      Please enter your name. Sammy Hi, Sammy! I'm Go!

      You now have a Go program that takes input from a user and prints it back to the screen.

      Conclusion

      In this tutorial, you wrote a "Hello, World!" program that takes input from a user, processes the results, and displays the output. Now that you have a basic program to work with, try to expand your program further. For example, ask for the user's favorite color, and have the program say that its favorite color is red. You might even try to use this same technique to create a simple Mad-Lib program.



      Source link

      How To Write Comments in Go


      Introduction

      Comments are lines that exist in computer programs that are ignored by compilers and interpreters. Including comments in programs makes code more readable for humans as it provides some information or explanation about what each part of a program is doing.

      Depending on the purpose of your program, comments can serve as notes to yourself or reminders, or they can be written with the intention of other programmers being able to understand what your code is doing.

      In general, it is a good idea to write comments while you are writing or updating a program as it is easy to forget your thought process later on, and comments written later may be less useful in the long term.

      Comments in Go begin with a set of forward slashes (//) and continue to the end of the line. It is idiomatic to have a white space after the set of forward slashes.

      Generally, comments will look something like this:

      // This is a comment
      

      Comments do not execute, so there will be no indication of a comment when running a program. Comments are in the source code for humans to read, not for computers to execute.

      In a “Hello, World!” program, a comment may look like this:

      hello.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          // Print “Hello, World!” to console
          fmt.Println("Hello, World!")
      }
      
      

      In a for loop that iterates over a slice, comments may look like this:

      sharks.go

      package main
      
      import (
          "fmt"
      )
      
      func main() {
          // Define sharks variable as a slice of strings
          sharks := []string{"hammerhead", "great white", "dogfish", "frilled", "bullhead", "requiem"}
      
          // For loop that iterates over sharks list and prints each string item
          for _, shark := range sharks {
              fmt.Println(shark)
          }
      }
      

      Comments should be made at the same indent as the code it is commenting. That is, a function definition with no indent would have a comment with no indent, and each indent level following would have comments that are aligned with the code it is commenting.

      For example, here is how the main function is commented, with comments following each indent level of the code:

      color.go

      package main
      
      import "fmt"
      
      const favColor string = "blue"
      
      func main() {
          var guess string
          // Create an input loop
          for {
              // Ask the user to guess my favorite color
              fmt.Println("Guess my favorite color:")
              // Try to read a line of input from the user. Print out the error 0
              if _, err := fmt.Scanln(&guess); err != nil {
                  fmt.Printf("%sn", err)
                  return
              }
              // Did they guess the correct color?
              if favColor == guess {
                  // They guessed it!
                  fmt.Printf("%q is my favorite color!n", favColor)
                  return
              }
              // Wrong! Have them guess again.
              fmt.Printf("Sorry, %q is not my favorite color. Guess again.n", guess)
          }
      }
      

      Comments are made to help programmers, whether it is the original programmer or someone else using or collaborating on the project. If comments cannot be properly maintained and updated along with the code base, it is better to not include a comment rather than write a comment that contradicts or will contradict the code.

      When commenting code, you should be looking to answer the why behind the code as opposed to the what or how. Unless the code is particularly tricky, looking at the code can generally answer the what or how, which is why comments are usually focused around the why.

      Block comments can be used to explain more complicated code or code that you don’t expect the reader to be familiar with.

      You can create block comments two ways in Go. The first is by using a set of double forward slashes and repeating them for every line.

      // First line of a block comment
      // Second line of a block comment
      

      The second is to use opening tags (/*) and closing tags (*/). For documenting code, it is considered idiomatic to always use // syntax. You would only use the /* ... */ syntax for debugging, which we will cover later in this article.

      /*
      Everything here
      will be considered
      a block comment
      */
      

      In this example, the block comment defines what is happening in the MustGet() function:

      function.go

      // MustGet will retrieve a url and return the body of the page.
      // If Get encounters any errors, it will panic.
      func MustGet(url string) string {
          resp, err := http.Get(url)
          if err != nil {
              panic(err)
          }
      
          // don't forget to close the body
          defer resp.Body.Close()
          var body []byte
          if body, err = ioutil.ReadAll(resp.Body); err != nil {
              panic(err)
          }
          return string(body)
      }
      

      It is common to see block comments at the beginning of exported functions in Go; these comments are also what generate your code documentation. Block comments are also used when operations are less straightforward and are therefore demanding of a thorough explanation. With the exception of documenting functions, you should try to avoid over-commenting the code and trust other programmers to understand Go, unless you are writing for a particular audience.

      Inline comments occur on the same line of a statement, following the code itself. Like other comments, they begin with a set of forward slashes. Again, it’s not required to have a whitespace after the forward slashes, but it is considered idiomatic to do so.

      Generally, inline comments look like this:

      [code]  // Inline comment about the code
      

      Inline comments should be used sparingly, but can be effective for explaining tricky or non-obvious parts of code. They can also be useful if you think you may not remember a line of the code you are writing in the future, or if you are collaborating with someone who you know may not be familiar with all aspects of the code.

      For example, if you don’t use a lot of math in your Go programs, you or your collaborators may not know that the following creates a complex number, so you may want to include an inline comment about that:

      z := x % 2  // Get the modulus of x
      

      You can also use inline comments to explain the reason behind doing something, or to provide some extra information, as in:

      x := 8  // Initialize x with an arbitrary number
      

      You should only use inline comments when necessary and when they can provide helpful guidance for the person reading the program.

      In addition to using comments as a way to document code, you can also use opening tags (/*) and closing tags (*/) to create a block comment. This allows you to comment out code that you don’t want to execute while you are testing or debugging a program you are currently creating. That is, when you experience errors after implementing new lines of code, you may want to comment a few of them out to see if you can troubleshoot the precise issue.

      Using the /* and */ tags can also allow you to try alternatives while you’re determining how to set up your code. You can also use block comments to comment out code that is failing while you continue to work on other parts of your code.

      multiply.go

      // Function to add two numbers
      func addTwoNumbers(x, y int) int {
          sum := x + y
          return sum
      }
      
      // Function to multiply two numbers
      func multiplyTwoNumbers(x, y int) int {
          product := x * y
          return product
      }
      
      func main() {
          /*
              In this example, we're commenting out the addTwoNumbers
              function because it is failing, therefore preventing it from executing.
              Only the multiplyTwoNumbers function will run
      
              a := addTwoNumbers(3, 5)
              fmt.Println(a)
      
          */
      
          m := multiplyTwoNumbers(5, 9)
          fmt.Println(m)
      }
      

      Note: Commenting out code should only be done for testing purposes. Do not leave snippets of commented out code in your final program.

      Commenting out code with the /* and */ tags can allow you to try out different programming methods as well as help you find the source of an error through systematically commenting out and running parts of a program.

      Conclusion

      Using comments within your Go programs helps to make your programs more readable for humans, including your future self. Adding appropriate comments that are relevant and useful can make it easier for others to collaborate with you on programming projects and make the value of your code more obvious.

      Commenting your code properly in Go will also allow for you to use the Godoc tool. Godoc is a tool that will extract comments from your code and generate documentation for your Go program.



      Source link