[Tune in every 2 weeks for Library Staff Highlights!]

Name: Sarah New

Hometown: Bel Air, MD, USA

Alma Mater: University of Virginia

Old code. Ugly code. Complicated code. Spaghetti code. Jibberish nonsense. In two words, Legacy Code. This is a series that will help you work and deal with it.

We first met our legacy source code in our previous lesson. Then we ran the code to form an opinion about its basic functionality and created a Golden Master test suite to have a raw safety net for future changes. We will continue to work on this code and you can find it under the trivia/php_start folder. The other folder trivia/php_start is with this lesson's finished code.

The time for the first changes have come and what better way to understand a difficult code base than start to extract magic constants and strings into variables? These seemingly simple tasks will give us greater and sometimes unexpected insights into the inner workings of legacy code. We will need to figure out the intentions of the original code author and find the proper names for the pieces of code that we've never seen before.

Magic Strings

Magic strings are strings used directly in various expressions, without being assigned to a variable. This kind of string had a special meaning for the original author of the code, but instead of assigning them to a well named variable, the author thought the meaning of the string was obvious enough.

Identify the First Strings to Change

Let's start by looking at our Game.php and try to identify strings. If you are using an IDE (and you should) or a smarter text editor capable of highlighting source code, spotting the strings will be easy. Here is an image of how the code looks like on my display.

Everything with orange is a string. Finding each string in our source code is very easy this way. So, make sure highlighting is supported and enabled in your editor, whatever your application is.

The first orange part in our code is immediately at line three. However the string contains only a newline character. This should be obvious enough in my opinion, so we can move on.

When it comes to deciding what to extract and what to keep unchanged, there are few thumb-ups, but at the end it is your professional opinion that must prevail. Based on it, you will have to decide what to do with each piece of code you analyze.

for ($i = 0; $i < 50; $i++) {
    		array_push($this->popQuestions, "Pop Question " . $i);
    		array_push($this->scienceQuestions, ("Science Question " . $i));
    		array_push($this->sportsQuestions, ("Sports Question " . $i));
    		array_push($this->rockQuestions, $this->createRockQuestion($i));
    	}
    }
    
    function createRockQuestion($index) {
    	return "Rock Question " . $index;
    }

So let's analyze lines 32 to 42, the snippet you can see above. For pop, science, and sports questions, there is just a simple concatenation. However, the action to compose the string for a rock question is extracted into a method. In your opinion, are these concatenations and strings clear enough so that we can keep all of them inside our for loop? Or, do you think extracting all strings into their methods would justify the existence of those methods? If so, how would you name those methods?

Update Golden Master and the Tests

Regardless of the answer, we will need to modify the code. It is time to put our Golden Master to work and write our test that actually runs and compares our code with the existing content.

class GoldenMasterTest extends PHPUnit_Framework_TestCase {
    
    	private $gmPath;
    
    	function setUp() {
    		$this->gmPath = __DIR__ . '/gm.txt';
    	}
    
    	function testGenerateOutput() {
    		$times = 20000;
    		$this->generateMany($times, $this->gmPath);
    	}
    
    	function testOutputMatchesGoldenMaster() {
    		$times = 20000;
    		$actualPath = '/tmp/actual.txt';
    		$this->generateMany($times, $actualPath);
    		$file_content_gm = file_get_contents($this->gmPath);
    		$file_content_actual = file_get_contents($actualPath);
    		$this->assertTrue($file_content_gm == $file_content_actual);
    	}
    
    	private function generateMany($times, $fileName) {...}
    
    	private function generateOutput($seed) {...}
    }

We created another test to compare the outputs, made sure testGenerateOutput() only generates the output once and does nothing else. We also moved the golden master output file "gm.txt" into the current directory because "/tmp" may be cleared when the system reboots. For our actual results, we can still use it. On most UNIX like systems "/tmp" is mounted into the RAM so it is much faster than the file system. If you did well, the tests should pass without a problem.

It is very important to remember to mark our generator test as "skipped" for future changes. If you feel more comfortable with commenting or even deleting it altogether, please do so. It is important that our Golden Master will not change when we change our code. It was generated once and we do not want to modify it, ever, so that we can be sure our newly generated code always compares to the original. If you feel more comfortable doing a backup of it, please proceed to do so.

function testGenerateOutput() {
    	$this->markTestSkipped();
    	$times = 20000;
    	$this->generateMany($times, $this->gmPath);
    }

I will just mark the test as skipped. This will put our test result to "yellow", meaning all tests are passing but some are skipped or marked as incomplete.

Making Our First Change

With tests in place, we can start changing code. In my professional opinion, all the strings can be kept inside the for loop. We will take the code from the createRockQuestion() method, move it inside the the for loop, and delete the method altogether. This refactoring is called Inline Method.

"Put the method's body into the body of its callers and remove the method." ~ Martin Fowler

There are a specific set of steps to do this type of refactoring, as defined by Marting Fowler in Refactoring: Improving the Design of Existing Code:

• Check that the method is not polymorphic.
• Find all calls to the method.
• Replace each call with the method body.
• Compile and test.
• Remove the method definition.

We don't have subclasses extending Game, so the first step validates.

There is only a single use of our method, inside the for loop.

function  __construct() {
    
    	$this->players = array();
    	$this->places = array(0);
    	$this->purses = array(0);
    	$this->inPenaltyBox = array(0);
    
    	$this->popQuestions = array();
    	$this->scienceQuestions = array();
    	$this->sportsQuestions = array();
    	$this->rockQuestions = array();
    
    	for ($i = 0; $i < 50; $i++) {
    		array_push($this->popQuestions, "Pop Question " . $i);
    		array_push($this->scienceQuestions, ("Science Question " . $i));
    		array_push($this->sportsQuestions, ("Sports Question " . $i));
    		array_push($this->rockQuestions, "Rock Question " . $i);
    	}
    }
    
    function createRockQuestion($index) {
    	return "Rock Question " . $index;
    }

We put the code from createRockQuestion() into the for loop in the constructor. We still have our old code. It is now time to run our test.

Our tests are passing. We can delete our createRockQuestion() method.

function  __construct() {
    
    	// ... //
    
    	for ($i = 0; $i < 50; $i++) {
    		array_push($this->popQuestions, "Pop Question " . $i);
    		array_push($this->scienceQuestions, ("Science Question " . $i));
    		array_push($this->sportsQuestions, ("Sports Question " . $i));
    		array_push($this->rockQuestions, "Rock Question " . $i);
    	}
    }
    
    function isPlayable() {
    	return ($this->howManyPlayers() >= 2);
    }

Finally we should run our tests again. If we missed a call to a method, they will fail.

They should pass again. Congrats! We are done with our first refactoring.

Other Strings to Consider

Strings in the methods add() and roll() are only used to output them using the echoln() method. askQuestions() compares strings to categories. This seems acceptable also. currentCategory() on the other hand returns strings based on a number. In this method, there are a lot of duplicated strings. Changing any category, except Rock would require changing its name in three places, only in this method.

function currentCategory() {
    	if ($this->places[$this->currentPlayer] == 0) {
    		return "Pop";
    	}
    	if ($this->places[$this->currentPlayer] == 4) {
    		return "Pop";
    	}
    	if ($this->places[$this->currentPlayer] == 8) {
    		return "Pop";
    	}
    	if ($this->places[$this->currentPlayer] == 1) {
    		return "Science";
    	}
    	if ($this->places[$this->currentPlayer] == 5) {
    		return "Science";
    	}
    	if ($this->places[$this->currentPlayer] == 9) {
    		return "Science";
    	}
    	if ($this->places[$this->currentPlayer] == 2) {
    		return "Sports";
    	}
    	if ($this->places[$this->currentPlayer] == 6) {
    		return "Sports";
    	}
    	if ($this->places[$this->currentPlayer] == 10) {
    		return "Sports";
    	}
    	return "Rock";
    }

I think we can do better. We can use a refactoring method called Introduce Local Variable and eliminate the duplication. Follow these guidelines:

• Add a variable with the desired value.
• Find all uses of the value.
• Replace all uses with the variable.

function currentCategory() {
    	$popCategory = "Pop";
    	$scienceCategory = "Science";
    	$sportCategory = "Sports";
    	$rockCategory = "Rock";
    
    	if ($this->places[$this->currentPlayer] == 0) {
    		return $popCategory;
    	}
    	if ($this->places[$this->currentPlayer] == 4) {
    		return $popCategory;
    	}
    	if ($this->places[$this->currentPlayer] == 8) {
    		return $popCategory;
    	}
    	if ($this->places[$this->currentPlayer] == 1) {
    		return $scienceCategory;
    	}
    	if ($this->places[$this->currentPlayer] == 5) {
    		return $scienceCategory;
    	}
    	if ($this->places[$this->currentPlayer] == 9) {
    		return $scienceCategory;
    	}
    	if ($this->places[$this->currentPlayer] == 2) {
    		return $sportCategory;
    	}
    	if ($this->places[$this->currentPlayer] == 6) {
    		return $sportCategory;
    	}
    	if ($this->places[$this->currentPlayer] == 10) {
    		return $sportCategory;
    	}
    	return $rockCategory;
    }

This is much better. You probably already observed some future improvements that we could do to our code, but we are only at the beginning of our work. It is tempting to fix everything you find immediately, but please don't. Many times, especially before the code is well understood, tempting changes can lead to dead ends or even more broken code. If you think there is a chance you will forget your idea, just note it on a sticky note or create a task in your project management software. Now we need to continue with our string related problems.

In the rest of the file, all strings are output related, sent into echoln(). For the time being, we will leave them untouched. Modifying them would effect the printing and delivering logic of our application. They are part of the presentation layer mixed with business logic. We will deal with separating different concerns in a future lesson.

Magic Constants

Magic constants are very much like magic strings, but with values. These values can be boolean values or numbers. We will concentrate mostly on numbers used in if statements or return statements or other expressions. If these numbers have an unclear meaning, we need to extract them into variables or methods.

include_once __DIR__ . '/Game.php';
    
    $notAWinner;
    
    $aGame = new Game();
    
    $aGame->add("Chet");
    $aGame->add("Pat");
    $aGame->add("Sue");
    
    do {
    
    	$aGame->roll(rand(0, 5) + 1);
    
    	if (rand(0, 9) == 7) {
    		$notAWinner = $aGame->wrongAnswer();
    	} else {
    		$notAWinner = $aGame->wasCorrectlyAnswered();
    	}
    
    } while ($notAWinner);

We'll start with GameRunner.php this time and our first focus is the roll() method that gets some random numbers. The previous author did not care to give those numbers a meaning. Can we? If we analyze the code:

rand(0, 5) + 1

It will return a number between one and six. The random part returns a number between zero and five to which we always add one. So it is surely between one and six. Now we need to consider the context of our application. We are developing a trivia game. We know there is some kind of board on which our players must move. And to do so, we need to roll the dice. A die has six faces and it can produce numbers between one and six. That seems like a reasonable deduction.

$dice = rand(0, 5) + 1;
    $aGame->roll($dice);

Isn't that nice? We used the Introduce Local Variable refactoring concept again. We named our new variable $dice and it represents the random number generated between one and six. This also made our next statement sound really natural: Game, roll dice.

Did you run your tests? I didn't mention it, but we need to run them as frequently as possible. If you haven't, this would be a good time to run them. And they should pass.

So, this was a case of nothing more than just exchanging a number with a variable. We took a whole expression that represented a number and extracted it into a variable. This can be technically considered a Magic Constant case, but not a pure case. What about our next random expression?

if (rand(0, 9) == 7)

This is more tricky. What are zero, nine and seven in that expression? Maybe we can name them. At first glance, I have no good ideas for zero and nine, so let's try seven. If the number returned by our random function is equal to seven, we will enter the first branch of the if statement which produces a wrong answer. So maybe our seven could be named $wrongAnswerId.

$wrongAnswerId = 7;
    if (rand(0, 9) == $wrongAnswerId) {
    	$notAWinner = $aGame->wrongAnswer();
    } else {
    	$notAWinner = $aGame->wasCorrectlyAnswered();
    }

Our tests are still passing and the code is somewhat more expressive. Now that we managed to name our number seven, it puts the conditional into a different context. We can think of some decent names for zero and nine also. They are just parameters to rand(), so the variables will probably be named min-something and max-something.

$minAnswerId = 0;
    $maxAnswerId = 9;
    $wrongAnswerId = 7;
    if (rand($minAnswerId, $maxAnswerId) == $wrongAnswerId) {
    	$notAWinner = $aGame->wrongAnswer();
    } else {
    	$notAWinner = $aGame->wasCorrectlyAnswered();
    }

Now that is expressive. We have a minimum answer ID, a maximum one and another for the wrong answer. Mystery solved.

do {
    
    	$dice = rand(0, 5) + 1;
    	$aGame->roll($dice);
    
    	$minAnswerId = 0;
    	$maxAnswerId = 9;
    	$wrongAnswerId = 7;
    	if (rand($minAnswerId, $maxAnswerId) == $wrongAnswerId) {
    		$notAWinner = $aGame->wrongAnswer();
    	} else {
    		$notAWinner = $aGame->wasCorrectlyAnswered();
    	}
    
    } while ($notAWinner);

But notice that all the code is inside a do-while loop. Do we need to re-assign the answer ID variables each time? I think not. Let's try to move them out of the loop and see if our tests are passing.

$minAnswerId = 0;
    $maxAnswerId = 9;
    $wrongAnswerId = 7;
    do {
    	$dice = rand(0, 5) + 1;
    	$aGame->roll($dice);
    
    	if (rand($minAnswerId, $maxAnswerId) == $wrongAnswerId) {
    		$notAWinner = $aGame->wrongAnswer();
    	} else {
    		$notAWinner = $aGame->wasCorrectlyAnswered();
    	}
    
    } while ($notAWinner);

Yes. The tests pass like this as well.

It's time to switch to Game.php and look for Magic Constants there also. If you have code highlighting, you surely have constants highlighted in some bright color. Mine are blue and they are pretty easy to spot.

Finding the magic constant 50 in that for loop was quite easy. And if we look at what the code does, we can discover that inside the for loop, elements are pushed to several arrays. So we have some kind of lists, each with 50 elements. Each list represents a question category and the variables are actually class fields defined above as arrays.

$this->popQuestions = array();
    $this->scienceQuestions = array();
    $this->sportsQuestions = array();
    $this->rockQuestions = array();

So, what can 50 represent? I bet you already have some ideas. Naming is one of the most difficult tasks in programming, if you have more than one idea and you feel uncertain which one to choose, don't be ashamed. I also have various names in my head and I am evaluating possibilities for choosing the best one, even while writing this paragraph. I think we can go with a conservative name for 50. Something along the lines of$questionsInEachCategory or $categorySize or something similar.

$categorySize = 50;
    for ($i = 0; $i < $categorySize; $i++) {
    	array_push($this->popQuestions, "Pop Question " . $i);
    	array_push($this->scienceQuestions, ("Science Question " . $i));
    	array_push($this->sportsQuestions, ("Sports Question " . $i));
    	array_push($this->rockQuestions, "Rock Question " . $i);
    }

That looks decent. We can keep it. And the tests are of course are passing.

function isPlayable() {
    	return ($this->howManyPlayers() >= 2);
    }

What is two? I am sure at this point the answer is clear to you. That is easy:

function isPlayable() {
    	$minimumNumberOfPlayers = 2;
    	return ($this->howManyPlayers() >= $minimumNumberOfPlayers);
    }

Do you agree? If you have a better idea, feel free to comment below. And your tests? Are they still passing?

Now, in the roll() method we have some numbers also: two, zero, 11 and 12.

if ($roll % 2 != 0)

That is pretty clear. We will extract that expression into a method, but not in this tutorial. We are still in the phase of understanding and hunting for magic constants and strings. So what about 11 and 12? They are buried inside the third level of if statements. It is quite difficult to understand what they stand for. Maybe if we look at the lines around them.

if ($this->places[$this->currentPlayer] > 11) {
    	$this->places[$this->currentPlayer] = $this->places[$this->currentPlayer] - 12;
    }

If the current player's place or position is greater than 11, then its position will be reduced to the current one minus 12. This sounds like a case of when a player reaches the end of the board or play field and it is repositioned in its initial position. Probably position zero. Or, if our game board is circular, going over the last marked position will put the player into the relative first position. So 11 could be the board size.

$boardSize = 11;
    if ($this->inPenaltyBox[$this->currentPlayer]) {
    	if ($roll % 2 != 0) {
    		// ... //
    		if ($this->places[$this->currentPlayer] > $boardSize) {
    			$this->places[$this->currentPlayer] = $this->places[$this->currentPlayer] - 12;
    		}
    		// ... //
    	} else {
    		// ... //
    	}
    } else {
    	// ... //
    	if ($this->places[$this->currentPlayer] > $boardSize) {
    		$this->places[$this->currentPlayer] = $this->places[$this->currentPlayer] - 12;
    	}
    // ... //
    }

Don't forget to replace 11 in both places inside the method. This will force us to move the variable assignment outside of the if statements, right at the first indentation level.

But if 11 is the board's size, what is 12? We subtract 12 from the player's current position, not 11. And why don't we just set the position to zero instead of subtracting? Because that would make our tests fail. Our previous guess that the player will end up in position zero after the code inside the if statement is run, was wrong. Let's say a player is in position ten and rolls a four. 14 is greater than 11, so the subtraction will happen. The player will end up in position 10+4-12=2.

This drives us toward another possible naming for 11 and 12. I think it is more appropriate to call 12 $boardSize. But what does that leave us for 11? Maybe $lastPositionOnTheBoard? A little bit long, but at least it tells us the truth about the magic constant.

$lastPositionOnTheBoard = 11;
    $boardSize = 12;
    if ($this->inPenaltyBox[$this->currentPlayer]) {
    	if ($roll % 2 != 0) {
    		// ... //
    		if ($this->places[$this->currentPlayer] > $lastPositionOnTheBoard) {
    			$this->places[$this->currentPlayer] = $this->places[$this->currentPlayer] - $boardSize;
    		}
    		// ... //
    	} else {
    		// ... //
    	}
    } else {
    	// ... //
    	if ($this->places[$this->currentPlayer] > $lastPositionOnTheBoard) {
    		$this->places[$this->currentPlayer] = $this->places[$this->currentPlayer] - $boardSize;
    	}
    // ... //
    }

I know, I know! There is some code duplication there. It is quite obvious, especially with the rest of the code hidden. But please remember that we were after magic constants. There will be a time for duplicate code also, but not right now.

Final Thoughts

I left one last magic constant in the code. Can you spot it? If you look at the final code, it will be replaced, but of course that would be cheating. Good luck finding it and thanks for reading.

Computer Engineering graduate student Alexander Nelson received an honorable mention for the National Science Foundation (NSF) Graduate fellowship. Alex’s research is focused on developing innovative cyber-physical systems that can dramatically improve a person’s standard of living in an impactful way. His current and past projects have involved emergency communications, assistive devices and home automation.

His prior research in assistive devices has gained acceptance to the 2013 IEEE Sensors Conference and 2013 Real Time Systems Symposium and contributed to a Microsoft Software Engineering Innovation Foundation award. His current research gained acceptance to a Works-in-Progress session at the 2013 Real Time Systems Symposium. His research co-mentors are Professors Nilanjan Banerjee and Ryan Robucci.

The NSF honorable mention designation is considered a significant national academic achievement and provides access to cyberinfrastructure resources through NSF’s Extreme Science and Engineering Discovery Environment (XSEDE) computing infrastruture. XSEDE is the most advanced, powerful, and robust collection of integrated advanced digital resources and services in the world. It is a single virtual system that scientists can use to interactively share computing resources, data, and expertise.

Computer Engineering graduate student Alexander Nelson received an honorable mention for the National Science Foundation (NSF) Graduate fellowship. Alex’s research is focused on developing innovative cyber-physical systems that can dramatically improve a person’s standard of living in an impactful way. His current and past projects have involved emergency communications, assistive devices and home automation.

His prior research in assistive devices has gained acceptance to the 2013 IEEE Sensors Conference and 2013 Real Time Systems Symposium and contributed to a Microsoft Software Engineering Innovation Foundation award. His current research gained acceptance to a Works-in-Progress session at the 2013 Real Time Systems Symposium. His research co-mentors are Professors Nilanjan Banerjee and Ryan Robucci.

The NSF honorable mention designation is considered a significant national academic achievement and provides access to cyberinfrastructure resources through NSF’s Extreme Science and Engineering Discovery Environment (XSEDE) computing infrastruture. XSEDE is the most advanced, powerful, and robust collection of integrated advanced digital resources and services in the world. It is a single virtual system that scientists can use to interactively share computing resources, data, and expertise.

The next generation of recommendation engines will use your location data to suggest music festivals, sporting events, and conferences you will want to attend.

Recommendation engines have flooded the Web. It’s hard to buy an ebook, mp3 track or video without being bombarded with suggestions for other purchases. Indeed, the phrase “people who bought X also liked Y” has become a modern-day aphorism

It’s reasonable to assume that a website’s loading time is important.

We can confidently conclude that slow sites have usability and SEO issues because we know that users hate waiting for web pages to load and that Google uses site speed as a factor for its search rankings.

But, quantitatively, what are the other effects of having a slow website?

Let us look at some cases of tech companies sharing what they have learned about web optimization.

Case Study: Amazon

While discussing his work on Big Data in a presentation (PDF or see a report here) Greg Linden shared the significance of site speed in terms of revenue.

In his work at Amazon — Linden, by the way, invented Amazon’s recommendation engine — he talked about how only a 100-millisecond delay could lead to revenues of the online company dropping by 1%.

Let’s do some back-of-the-napkin calculations.

Last year alone, Amazon’s estimated revenue totaled $74.5 billion.

Based on Linden’s disclosure, increasing page loading times by just a fraction of a second would cost Amazon $745 million a year in lost revenue!

Case Study: Bing

In a joint conference presentation, Eric Schurman (from Bing) and Jake Brutlag (from Google) discussed the impact of web server delays.

Bing performed an experiment testing to see what would happen if their pages loaded 1.5 seconds longer than usual.

The results?

Source

Among other key metrics, they saw decreases in:

• User satisfaction (-3.8%)
• Revenue per user (-4.3%)
• Number of clicks (-4.4%).

Case Study: Akamai

Akamai is a longstanding industry leader in the content delivery space.

In 2009, the company conducted a survey research study involving over 1,000 online shoppers.

This is what they discovered:

• The threshold is 2 seconds — more than that and the user will become impatient
• 40% of the respondents will abandon the site if it takes more than 3 seconds to load

These stats all equate to one thing: Considerable amount of losses in revenue.

Case Study: Google

In a talk, Marissa Mayer — then a VP at Google and today Yahoo’s CEO — discussed an experiment (video) she and her team ran on Google’s search results page.

They tested the effects of displaying more results in Google searches: 10 search results vs. 30 search results.

Analyzing their data, they witnessed 25% fewer searches from users that saw more search results.

Source

But was it because displaying more results meant users found what they were looking for on the first search results page, and so they felt no need to perform additional searches?

After further investigation, they attributed this drop in searches (i.e. page impressions) to increased page load times.

On average, the group that had more search results were subjected to longer page response times (0.9 seconds) vs. the group with fewer search results but got the page loaded quicker at only 0.4 seconds.

In conclusion, Google discovered that even a few milliseconds of delay — just 500ms to be exact — could lead to a notable reduction in page impressions.

Case Study: Shopzilla

A few years ago, Shopzilla embarked on a major, two-year-long redesign of their site.

During this time, Shopzilla was already huge — they received between 20-29 million unique visitors a month and 8,000 searches per second. Optimizing website performance to handle this sort of traffic thus became crucial.

Their web optimization efforts led to significant improvements — up to a 5-second reduction in page-loading times.

Phil Dixon, VP of Engineering at Shopzilla shared data and the lessons the company learned during their optimization efforts.

They witnessed amazing growth in important metrics by improving their website’s speed:

• Conversion rates increased by 7-12%
• Page views increased by 25% — just imagine how much more page views they gained just by focusing on improving site speed, because they were already getting 100 million impressions per day

Case Study: AOL

While sharing some key metrics, David Artz — Director of Website Optimization at AOL and the co-author of the book Website Optimization – concluded that:

"Visits experiencing the fastest load times delivered us [AOL] the most page views per visit"

Source

This was because in the sections of AOL.com tested, they saw up to a 160% increase in average number of page views from users in the group who were in the top 10% in terms of average load time (fastest experience), compared to those at the bottom 10% (slowest experience).

Conclusion

These studies impart upon us one important lesson: Website speed should be a high priority if we want to build great websites.

Based on these reports, we have evidence suggesting that having a slow website will have negative effects on revenue, conversion rates, usability, and UX.

How to Speed Up Your Website

If you feel that your site’s speed needs improvement, read these articles to get started:

• 10 Ways to Improve Your Web Page Performance
• 20 Free Online Tools for Website Speed Testing
• 10 Tips for Optimizing Your Website’s Speed
• 10 Tips for Decreasing Web Page Load Times
• 8 Excellent WordPress Caching Plugins to Speed Up Your Site

Read Also

• 10 Usability Tips Based on Research Studies
• 5 Usability Mistakes You Shouldn’t Make
• Use the 80-20 Rule to Increase Your Website’s Effectiveness
• Agile Web Development That Works

About the Author

Smriti Chawla works at Visual Website Optimizer,a popular A/B testing and heat-mapping tool. Read more articles on A/B testing and high-converting design ideas by visiting the Visual Website Optimizer Blog. Connect with Smriti on Twitter.

The post Why Website Speed is Important appeared first on Six Revisions.

With the recent developments in online privacy it is just about the right time to suggest small tweaks to improve your terms & conditions and privacy policy documents on your own websites. As the examples below show, there are various ways to make these documents (in addition to its legal validity) more than just text in a way that will benefit your visitors.

But wait, before we start, you might want to know why this is even relevant? Why do websites (and apps) need a privacy policy and terms of service? And what do you usually include in those documents?

For one, privacy policies are relevant (and legally required) in most countries—they are a way to disclose your data collection practices. (Did you know that you are required to have a privacy policy when you use Google Analytics?) It is also the right thing to do according to your visitors/customers: MEF’s Global Privacy Report from early 2013 revealed that 70% of consumers say it’s important to know exactly what personal information is being collected and shared.

Terms of Service can mainly help you to avoid responsibility for the actions of your users. They are therefore an important way of helping you stay out of trouble.

Here’s what’s usually is covered by a Terms & Conditions document:

• Disambiguation/definition of key words and phrases
• User rights and responsibilities
• Proper or expected usage; potential misuse
• Accountability for online actions, behavior, and conduct
• Privacy: pointing to the privacy policy and defining as part of the contract
• Privacy policy outlining the use of personal data
• Payment details such as membership or subscription fees, etc.
• Opt-out policy describing procedure for account termination, if available
• Disclaimer/Limitation of Liability clarifying the site’s legal liability for damages incurred by users
• User notification upon modification of terms, if offered

Here’s what usually needs to be included in a Privacy Policy:

• What kind of personal data is being collected
• Describe how this information will be used by the company
• Describe how this information will be transferred to third party companies
• Provide instructions on how users can modify or delete their personal information
• Provide instructions on how users can opt-out of future communications
• Identify its effective date and outline how you notify people of material changes to your privacy policy

Case Studies

Sprout Social — summary on top

I couldn’t find this User Agreement at Sprout Social anymore (taken from my archives), but the screenshot is self-explanatory. Above the actual user agreement, the most important points were summarized in an easily digestible manner.

FullContact — summarize/hide

Here’s a similar approach by FullContact, they summarize the actual content and hide it. If you want to learn more, the full text appears.

Mite — summary by paragraph

Mite’s terms of service and privacy policy summarize every paragraph by saying stated briefly what the legal speak means in plain English.

MailChimp — helpful definitions

MailChimp adds helpful definitions next to their paragraphs. They add information to the reading flow when something isn’t necessarily understandable for an average user.

The example below is MailChimp’s paragraph requiring you to comply with local and international laws like spam and privacy regulation. They explain the abbreviation EEA to clarify what their terms mean to you: “This applies to people who are sending to or from the European Economic Area. The EEA includes countries that are part of the European Union, plus Iceland, Liechtenstein, and Norway.”

Fragmentation

Moving on, but staying with Mailchimp. When doing your docs online, try to avoid putting everything in one document and group them by topic. Most importantly a privacy policy shouldn’t be buried in something like the terms or legal information regarding your company (required in a lot of European countries. In Spain they call it aviso legal, in Germany impressum).

Mailchimp’s way of grouping the legal documents, making it easy for you to understand where to look and what to expect.

Here’s a similar grouping implementation by Dropbox:

iubenda — icons/simplified and full legal text view

iubenda has a full system for their privacy policies. They combine an easily digestible view for visitors where the focus is on quick understanding and text is accompanied by icons with a page that shows actual legally relevant text. (Full disclosure: I have recently joined iubenda which is why I have insights into how they work. A lot of emphasis is put on ease of use for both web designers using the service and the visitors reading the policies).

Upworthy — use an infographic image

Use an infographic style image to explain what your users are to expect from you. This one has no real legal validity, but they additionally have one that may have below that image:

DuckDuckGo — tell a story

DuckDuckGo’s example is far away from being an actual privacy policy. What they did here is set themselves apart from the competition by telling a story and therefore outline what their privacy policy is all about. Again, they also have an actual policy on their site that complies with actual legal regulations. To make this stand out even more as a story, this policy sits on a separate site called donttrack.us.

CloudFlare — track changes on Github

CloudFlare tracks their changes on Github, so you can always see how the policies may have changed. Often a policy just shows the date of its latest startup. This is a great way of improving transparency and therefore trust.

What makes great legal documentation on the web isn’t just legally compliant text for your particular audience. It’s also easily understandable language and helps the user comprehend what it’s all about in a visual fashion. Hopefully this post will give you some ideas about how to design your documents in the future.

Featured image/thumbnail, legal checks image via Shutterstock.

Noem9studio’s Essay Font Family, 8 Styles – only $9!