‘Eventoz’ is a free One Page Event HTML template by MarkUps.io. Features include a sticky navigation that smooth scrolls down to relevant sections, a countdown timer, video popup modal, speaker schedule (split by days), speaker info slider, venue details with Google Maps, pricing table (that you could link to a service like Shopify for secure checkout), registration form and an FAQs accordion.
This article is part of a series created in partnership with SiteGround. Thank you for supporting the partners who make SitePoint possible.
Are you in the process of choosing a web hosting provider? Then you’ve already heard of SiteGround. They’re one of the most recommended companies out there. And at just 10 years old, they’re also one of the youngest.
That’s impressive. But are all those reviews and recommendations accurate? Is SiteGround actually as good as they seem? They’re obviously doing a lot of things right, but it’s hard to know how they stack up without signing up and giving them a go.
So that’s what I did.
I’ve been using a variety of hosting providers (including GoDaddy and Crazy Domains) since 2007. In March 2017 I grabbed a SiteGround GrowBig account with my own money, and transferred one of my sites.
With four months experience using SiteGround and their free migration service, contacting support, and evaluating performance, I’ve also been studying the company in a couple of other ways:
So I feel uniquely qualified to give a detailed opinion of how SiteGround stacks up to the competition. But first, what plans do they offer?
SiteGround offer shared hosting, cloud hosting, dedicated servers, and custom-made hosting solutions for enterprise. In this article we’ll focus on their three shared hosting plans.
Crafted for a great web start
SiteGround’s least expensive plan is designed for someone starting out with their first (single) website:
The StartUp Plan gives you all the essential hosting features you need to accommodate a "just getting started" website or an existing average-size blog, personal, or business website. The StartUp Plan works well even for smaller online shops with a reasonable number of products. You will most probably outgrow this plan if you start attracting more than 10,000 unique visits per month on a regular basis.
The StartUp plan offers the following features and services:
One of the biggest barriers to changing hosting provider is the amount of effort involved in migrating your website to the new company’s servers. That hurdle can lead to endless procrastination, with you staying with a company you’re not entirely happy with.
SiteGround doesn’t want that to stop you! So they offer free setup and transfer of one website. I used this service when migrating my site from GoDaddy, and you can read about my experiences in A Review of SiteGround’s Migration Service. After supplying the necessary login details and clarifying a few questions, the migration was performed quickly and effortlessly. The entire process took just a couple of days.
Of course, SiteGround is not the only company to offer a website migration service. But they’re one of the only ones who do it free of charge—HostGator is another. Most companies see it as an optional paid add-on. GoDaddy charges $99.99 for their migration service, and Bluehost $149.99.
We all know about the importance of computer backups, and hopefully we do something about it. Your website is one more resource that needs to be backed up, and SiteGround (together with most hosting providers) will back it up for free. That’s handy, though I recommend you keep your own backups as part of your regular website maintenance.
The rubber hits the road when you need that backup! How easy is it to restore your data? And is there an additional cost? With SiteGround it’s easy. They give you the ability to restore your backups for free. No fuss, no wait, no fee. Bluehost do the same.
But not all companies make it so easy. HostGator prefer to restore your website for you, so you fill in an online form requesting the restore, and then wait for them to do it.
Other companies charge for each restore. I was shocked to learn (the hard way) that GoDaddy charges $149.99 to restore your website. That puts a totally different spin on a “free” backup!
HTTP is the future, the latest evolution of the Hypertext Transfer Protocol (HTTP). The new protocol’s main aim is to speed access to your website by reducing latency. And it succeeds. HTTP/2 is around ten times faster!
When both the web browser and server support the new protocol, you get that speed bump today. Recent versions of Firefox, Safari, Edge and Chrome all support HTTP/2, but what about your web host?
For shared hosting, many hosting providers don’t yet support HTTP/2. Bluehost doesn’t, HostGator doesn’t, and GoDaddy doesn’t. SiteGround supports it today.
Security is an issue constantly growing in importance. Make sure your site offers secure, private connections for all users by offering HTTPS access. To do this, you need SSL.
Let’s Encrypt is a free SSL service. SiteGround set it up for you and look after all certificate renewals. Other SSL options are available, and one is included free with the higher-tier plans.
How does that compare with the competition? Well, you won’t get free SSL with any other entry level hosting plan. GoDaddy don’t include it with any of their shared hosting plans, while HostGator and Bluehost include it with their more expensive third-tier plans.
Of course, they all let you set up your own SSL solution, but at this price point, only SiteGround does the work for you. Learn more in our article Why Every Site Needs HTTPS.
A content delivery network is another way to boost the performance of your website. It takes the load off your server by storing your static resources elsewhere. That includes images and other attachments, as well as scripts and CSS files. SiteGround includes CloudFlare, one of the most popular CDNs, with your shared hosting account.
How does that compare with other providers? While GoDaddy doesn’t include a CDN with their shared hosting plans at this time, other providers (including Bluehost and HostGator) also include CloudFlare.
People often work on their websites outside of business hours, and commonly well after midnight. Do you relate? Hopefully you won’t need to contact support often, but when you do it may be urgent, and you won’t want to wait for an answer.
Quality 24/7 technical support is a must, and SiteGround has the best in the business.
How does SiteGround’s support stack up to the competition? It surpasses it. Learn more in the “How Does SiteGround Stack Up?” section of this review.
Choosing a web hosting provider can be an ordeal. There’s so much to consider. But you won’t really get to know your hosting provider until after you sign up. A money-back guarantee gives you peace of mind.
SiteGround offer a 30 day money-back guarantee on all of their shared hosting plans. Other popular hosting providers offer similar terms.
cPanel is a popular web hosting control panel that allows you to easily access all the features of your plan. SSH is a geekier way to log into your web host. SiteGround, and all popular hosting providers, offer both.
SSD storage is one way to give your laptop a huge speed boost—it is significantly faster than spinning hard drives. SiteGround has given the same speed boost to your website by using only SSD storage on their servers. The practice is catching on, and now other hosting providers (including GoDaddy, Bluehost and HostGator) do the same.
Continue reading %SiteGround Review: Shared Hosting that Stacks Up%
React is a framework that has made headway within the JavaScript developer community. React has a powerful composition framework for designing components. React components are bits of reusable code you can wield in your web application.
React components are not tightly coupled from the DOM, but how easy are they to unit test? In this take, let’s explore what it takes to unit test React components. I’ll show the thought process for making your components testable.
Keep in mind, I’m only talking about unit tests, which are a special kind of test. (For more on the different kinds of tests, I recommend you read “JavaScript Testing: Unit vs Functional vs Integration Tests”.)
With unit tests, I’m interested in two things: rapid and neck-breaking feedback. With this, I can iterate through changes with a high degree of confidence and code quality. This gives you a level of reassurance that your React components will not land dead on the browser. Being capable of getting good feedback at a rapid rate gives you a competitive edge --- one that you’ll want to keep in today’s world of agile software development.
For the demo, let’s do a list of the great apes, which is filterable through a checkbox. You can find the entire codebase on GitHub. For the sake of brevity, I’ll show only the code samples that are of interest. This article assumes a working level of knowledge with React components.
If you go download and run the demo sample code, you’ll see a page like this:
In React, a good approach is to start with a hierarchy of components. The single responsibility principle comes to mind when building each individual component. React components use object composition and relationships.
For the list of the great apes, for example, I have this approach:
FilterableGreatApeList
|_ GreatApeSearchBar
|_ GreatApeList
|_ GreatApeRow
Take a look at how a great ape list has many great ape rows with data. React components make use of this composition data model, and it's also testable.
In React components, avoid using inheritance to build reusable components. If you come from a classic object-oriented programming background, keep this in mind. React components don’t know their children ahead of time. Testing components that descend from a long chain of ancestors can be a nightmare.
I’ll let you explore the FilterableGreatApeList on your own. It's a React component with two separate components that are of interest here. Feel free to explore the unit tests that come with it, too.
To build a testable GreatApeSearchBar, for example, do this:
class GreatApeSearchBar extends Component {
constructor(props) {
super(props);
this.handleShowExtantOnlyChange = this.handleShowExtantOnlyChange.bind(this);
}
handleShowExtantOnlyChange(e) {
this.props.onShowExtantOnlyInput(e.target.checked);
}
render() {
return(
<form>
<input
id="GreatApeSearchBar-showExtantOnly"
type="checkbox"
checked={this.props.showExtantOnly}
onChange={this.handleShowExtantOnlyChange}
/>
<label htmlFor="GreatApeSearchBar-showExtantOnly">Only show extant species</label>
</form>
);
}
}
This component has a checkbox with a label and wires up a click event. This approach may already be all too familiar to you, which is a very good thing.
Note that with React, testable components come for free, straight out of the box. There's nothing special here --- an event handler, JSX, and a render method.
The next React component in the hierarchy is the GreatApeList, and it looks like this:
class GreatApeList extends Component {
render() {
let rows = [];
this.props.apes.forEach((ape) => {
if (!this.props.showExtantOnly) {
rows.push(<GreatApeRow key={ape.name} ape={ape} />);
return;
}
if (ape.isExtant) {
rows.push(<GreatApeRow key={ape.name} ape={ape} />);
}
});
return (
<div>
{rows}
</div>
);
}
}
It's a React component that has the GreatApeRow component and it’s using object composition. This is React’s most powerful composition model at work. Note the lack of inheritance when you build reusable yet testable components.
In programming, object composition is a design pattern that enables data-driven elements. To think of it another way, a GreatApeList has many GreatApeRow objects. It's this relationship between UI components that drives the design. React components have this mindset built in. This way of looking at UI elements allows you to write some nice unit tests.
Here, you check for the this.props.showExtantOnly flag that comes from the checkbox. This showExtantOnly property gets set through the event handler in GreatApeSearchBar.
For unit tests, how do you unit test React components that depend on other components? How about components intertwined with each other? These are great questions to keep in mind as we get into testing soon. React components may yet have secrets one can unlock.
For now, let’s look at the GreatApeRow, which houses the great ape data:
class GreatApeRow extends Component {
render() {
return (
<div>
<img
className="GreatApeRow-image"
src={this.props.ape.image}
alt={this.props.ape.name}
/>
<p className="GreatApeRow-detail">
<b>Species:</b> {this.props.ape.name}
</p>
<p className="GreatApeRow-detail">
<b>Age:</b> {this.props.ape.age}
</p>
</div>
);
}
}
With React components, it's practical to isolate each UI element with a laser focus on a single concern. This has key advantages when it comes to unit testing. As long as you stick to this design pattern, you’ll find it seamless to write unit tests.
Continue reading %A Guide to Testing React Components%
If you have been following this series from the beginning, you might have noticed that Plotly.js uses the same scatter type for creating both line charts and bubble charts. The only difference is that we had to set the mode to lines while creating line charts and markers when creating bubble charts.
Similarly, Plotly.js allows you to create pie, donut and gauge charts by using the same value for the type attribute and changing the value of other attributes depending on the chart you want to create.
You can create pie charts in Plotly.js by setting the type attribute to pie. There are also other attributes like opacity, visible and name that are common to other chart types as well. The name attribute is used to provide a name for the current pie trace. This name is then shown in the legend for identification. You can show or hide the pie trace in the legend of a chart by setting the showlegend attribute to true or false respectively. You can set a label name for the different sectors of a pie chart by using the labels attribute.
In the case of pie charts, the marker object is used to control the appearance of different sectors of the chart. The color attribute nested inside marker can be used to set the color of each sector of the pie chart. The color for different sectors can be specified as an array value to the color attribute.
You can also set the color and width of all the lines enclosing each sector using the color and width attributes nested inside the line object. You also have the option to sort all the sectors of the pie chart from largest to smallest using the boolean sort attribute. Similarly, the direction of the sectors can be changed to clockwise or counterclockwise with the help of the direction attribute.
The following code creates a basic pie chart that lists the forested area of the top five countries in the world.
var pieDiv = document.getElementById("pie-chart");
var traceA = {
type: "pie",
values: [8149300, 4916438, 4776980, 3100950, 2083210],
labels: ['Russia', 'Canada', 'Brazil', 'United States', 'China']
};
var data = [traceA];
var layout = {
title: "Area Under Forest for Different Countries"
};
Plotly.plot(pieDiv, data, layout);
As you can see, we are no longer using the x and y attributes to specify the points that we want to plot. This is now done with the help of values and labels. The percentages are determined automatically based on the input values.
By default, the first slice of the pie starts at 12 o'clock. You can change the starting angle of the chart using the rotation attribute, which accepts a value between -360 and 360. The default 12 o'clock value is equal to the angle 0.
If you want a slice in your chart to stand out, you can use the pull attribute, which can accept either a number or an array of numbers with values between 0 and 1. The pull attribute is used to pull the specified sectors out of the pie. The pull distance is equal to a fraction of the larger radius of the pie or donut.
It is very easy to convert a pie chart into a donut chart by specifying a value for the hole attribute. It will cut the given fraction of the radius out from the pie to make a donut chart.
You can control the color of individual sectors in a pie chart using the colors attribute nested inside the marker object. The width and color of the line that encloses each sector can also be changed with the help of the width and color attributes nested inside the line object. The default width of the enclosing line is 0. This means that no line will be drawn around the sectors by default.
There is also a hovertext attribute, which can be used to provide some extra textual information for each individual sector. This information will be visible to viewers when they hover over a sector. One condition for the text to appear is that the hoverinfo attribute should contain a text flag. You can set the color of text lying inside or outside of the pie sectors using the family, size and color attributes nested inside the insidetextfont and outsidetextfont objects respectively.
The following code uses the data from our previous pie chart to create a donut chart that uses the additional attributes we just learned about.
var pieDiv = document.getElementById("pie-chart");
var traceA = {
type: "pie",
values: [8149300, 4916438, 4776980, 3100950, 2083210],
labels: ['Russia', 'Canada', 'Brazil', 'United States', 'China'],
hole: 0.25,
pull: [0.1, 0, 0, 0, 0],
direction: 'clockwise',
marker: {
colors: ['#CDDC39', '#673AB7', '#F44336', '#00BCD4', '#607D8B'],
line: {
color: 'black',
width: 3
}
},
textfont: {
family: 'Lato',
color: 'white',
size: 18
},
hoverlabel: {
bgcolor: 'black',
bordercolor: 'black',
font: {
family: 'Lato',
color: 'white',
size: 18
}
}
};
var data = [traceA];
var layout = {
title: "Area Under Forest for Different Countries"
};
Plotly.plot(pieDiv, data, layout);
The basic structure of a gauge chart is similar to a donut chart. This means that we can use some cleverly selected values and create simple gauge charts by still keeping the type attribute set to pie. Basically, we will be hiding some sections of the full pie to make it look like a gauge chart.
First, we need to choose some values for the values attribute. To keep things simple, I will be using the top half of the pie as my gauge chart. This means that the values should be divided equally between the part that I want to be visible and the part of the pie chart that I want to hide. The visible section of the chart can further be divided into smaller parts. Here is an example of choosing the values for our gauge chart.
values: [100 / 5, 100 / 5, 100 / 5, 100 / 5, 100 / 5, 100]
The number 100 in the above line is arbitrary. As you can see, the first five slices together add up to 100, which is also the value set for the hidden area of the pie chart. This divides the whole pie equally between the hidden and visible part.
Here is the complete code that creates our basic gauge chart. You should note that I have set the color attribute of the sector that should be hidden to white. Similarly, the text and labels values for the corresponding sector have also been set to empty strings. The rotation attribute has been set to 90 so that the chart is not drawn from its default 12 o'clock position.
var gaugeDiv = document.getElementById("gauge-chart");
var traceA = {
type: "pie",
showlegend: false,
hole: 0.4,
rotation: 90,
values: [100 / 5, 100 / 5, 100 / 5, 100 / 5, 100 / 5, 100],
text: ["Very Low", "Low", "Average", "Good", "Excellent", ""],
direction: "clockwise",
textinfo: "text",
textposition: "inside",
marker: {
colors: ["rgba(255, 0, 0, 0.6)", "rgba(255, 165, 0, 0.6)", "rgba(255, 255, 0, 0.6)", "rgba(144, 238, 144, 0.6)", "rgba(154, 205, 50, 0.6)", "white"]
},
labels: ["0-10", "10-50", "50-200", "200-500", "500-2000", ""],
hoverinfo: "label"
};
The next part of the code deals with the needle of the gauge chart. The value that you set for the degrees variable will determine the angle at which the needle is drawn. The radius variable determines the length of the needle. The attributes x0 and y0 are used to set the starting point of our line. Similarly, the attributes x1 and y1 are used to set the ending point of our line.
You can create more complex shapes for your needle with the help of SVG paths. All you have to do is set the type attribute to path and specify the actual path using the path attribute. You can read more about it in the layout shapes section of the reference.
var degrees = 115, radius = .6;
var radians = degrees * Math.PI / 180;
var x = -1 * radius * Math.cos(radians);
var y = radius * Math.sin(radians);
var layout = {
shapes:[{
type: 'line',
x0: 0,
y0: 0,
x1: x,
y1: 0.5,
line: {
color: 'black',
width: 8
}
}],
title: 'Number of Printers Sold in a Week',
xaxis: {visible: false, range: [-1, 1]},
yaxis: {visible: false, range: [-1, 1]}
};
var data = [traceA];
Plotly.plot(gaugeDiv, data, layout, {staticPlot: true});
All the code of this section creates the following gauge chart. Right now, the chart is not very fancy, but it can act as a good starting point.
In this tutorial, you learned how to create pie and donut charts using the pie trace type in Plotly.js. You also learned how to carefully set the values of a few attributes to convert those pie charts into simple gauge charts. You can read more about pie charts and their different attributes on the reference page.
This was the last tutorial of our interactive Plotly.js charts series. The first introductory tutorial provided you an overview of the library. The second, third and fourth tutorials showed you how to create line charts, bar charts, and bubble charts respectively. I hope you enjoyed this tutorial as well as the whole series. If you have any questions, feel free to let me know in the comments.
Want to create an intensely loyal fan base for your product? Wondering how a product evangelist can help? To explore how product evangelism supports the sales process, I interview Guy Kawasaki. More About This Show The Social Media Marketing podcast is an on-demand talk radio show from Social Media Examiner. It’s designed to help busy [...]
This post Product Evangelism: How to Evangelize and Create Advocates first appeared on .
- Your Guide to the Social Media Jungle