I use WordPress for both developing websites in it, but also for hosting my blogs.

If you want to check it out, just click:

https://wordpress.com/refer-a-friend/Qp724w3hVxKKzmBG6xgj/

First of all, I needed a way to simulate real life user interaction with a website. For this, you need a browser. My first choice was PhantomJs but it turned out to be difficult to work with. After a lot of research, I finally stayed with headless chrome.

So now, that I had a browser, I needed to simulate user interaction. Also, I wanted the views to be from different parts of the world, not just from one IP address, so for that I needed to somehow use proxy’s. I found a way to either use a proxy from a file, or always load the latest proxy list from an online source.

https://raw.githubusercontent.com/clarketm/proxy-list/master/proxy-list.txt

After I had the proxy’s, I needed the interaction to seem random, so I randomized the browser headers, the links the bot followed and the length of time it stayed on a page.

Finally I had a running script that could generate 200+ views.

My first page view generator was ready and tested. You can find technical information in the README of the project.

Here is the code for those who are eager to give it a try:

https://gitlab.com/Gadratil/pvg

It is an increasing trend to create applications that run on the internet, instead of running on the client device. Also, there are applications that come from the server, but do the heavy load on the client side. Web interfaces are very common and you need to download less and less applications.

So, in this era, why would someone move to the cloud?

What moving to the cloud means

Moving to the cloud means keeping your data on servers and not on your own device. The best example probably is keeping your photos online. This has many forms, for example you make a lot of pictures for your social sites, they are kept in the “cloud”, meaning on the servers of the given social site. There are file syncing applications also, like Google Drive or One Drive that keep a copy of the shared files in the cloud, so no matter what happens to your device, your files are safe. This started to be a bigger and bigger trend and it is good, because it shifts us from being so dependent of our devices.

In a near future I can imagine a case when our devices have only one functionality: accessing the internet. Our everything would be online, in the cloud, so the device just has to grant us access.

A simple example of using the cloud

I personally use the cloud to store data that I do not want to lose. I store my credentials for example in the cloud, scattered in many places. In this way I do not have to remember all my passwords (I have soooo many!), I just have to remember where I scattered the data. Also, I keep important files also in the cloud, like scripts written by me, documentations, important personal documents.

Personal documents are a good example, because if you need any of them, you just download them on your phone and print them. This kind of accessibility saves you a lot of time.

Concerns about cloud safety

Many fear to share their data with the cloud, to keep their personal things online. They say that these technologies are not safe enough, that their personal files could leak out.

The thing is, that your device is probably more vulnerable on a network than a Google server. So leaking data from your personal device is more likely than from a Google server.

Of course, you have the right to keep your data where you want it. When data gets lost, it gets lost. It can be a piece of paper, too, if you lose it, the data on it is lost. So, keeping multiple copy’s is always a good practice, no matter where you keep your data.

I usually have nothing to hide, so I am not afraid to keep data in the cloud. The intellectual property I have can be stolen, of course, but I have the knowledge to recreate it, and the one who stole it does not necessarily understand it.

Conclusion

Nowadays the Cloud is a safe place to keep your things in. Just trust the big providers, they know what to do. Moving to the cloud enables you to become device independent and that is a pretty big freedom if you ask me.

Adware is an expression for software that is harmful for your PC or Phone. It makes you vulnerable to other harmful software and fills your browsers with popups, add-ons, bars and all kinds of annoying things. Also, these can significantly slow down your computer or phone.

Usually people get these adware from the internet in different forms. They come with some free software you download, or simply you click on a wrong link on a webpage.

Let’s talk about browsing habits. It is very important to follow these rules when browsing the internet:

• Be patient. Clicking like a maniac on a link can make you click on something you did not want.
• Never register anywhere if you do not trust that website
• If you are uncertain about a website, search for it on forums, find out what other people think
• Never click on flashy, fancy, big buttons on a website
• Modern browsers have everything to watch videos or to play games, you DO NOT have to download extra plugins or stuff like that. Those are probably full of viruses and adware.
• DO NOT download things you do not know or do not trust
• Always use a virus scanning tool, those can help you prevent downloading unwanted software
• If you are uncertain, ask someone who knows better

Following these browsing habits do not guarantee success on being clean of viruses and other harmful software. Once you get infected, there are things you can do to clean your computer or phone:

• Uninstall all programs you do not use or do not know.
• Use the antivirus tool`s full scan to find viruses
• Use dedicated adware removal tools, like Adware Removal Tool
• Run a cleaning tool to clean temporary files from your system
• Again, ask someone who knows better

There are so many types of scams that it is not easy to filter them all, so it happens that you get infected anyway or you cannot disinfect your device by your own. It is better to ask the help of a professional in these cases, otherwise you can lose more than paying a simple service.

First of all, you have to activate it. Currently Graph Search only works on English language, so you have to enable it by changing your language to English(US). After you changed the language, you just type the things you want to search in the search field.

Graph Search is a bit like an SQL query, but in a more human language. For example you can type in: people in last month liked by <name of someone>. This will find all the people who were liked by the person you type in. Usually these searches are narrowed to your friends, so probably you will not be able to see the pictures liked by a celebrity who is not your friend.

Some other examples:

•  photos of males / females liked by <name of friend>
• events liked by <name of friend>
• photos of me liked by <person 1> and <person 2>
• books <person> and I are interested in

Graph Search is almost limitless, you can search a lot of things with it. Take care however, because you can find things you are not prepared or Good searching for everyone. If you need help with given examples, just write in the comments or on Facebook at https://www.facebook.com/gadratilprogramming/

A tree is a scructure of data used for categories, showing hierarchy and so on. In web applications usually the most used case is creating category hierarchy, menu hierarchy or page hierarchy. Currently there are a lot of ways to create tree scructures in PHP, but we will use just one example, one that is very flexible and adaptable for many usecases.

Example of a tree

For the sake of simplicity, we will use a very simple tree for example. Our tree looks like this:

This is a one depth tree with four nodes in total. In trees, the nodes that have children are called branches and the ones that have none are called leaves.

How to store a tree

When working with simple trees, storing the hierarchy is not that hard. Usually, in the database we can create a parent column that contains the parent of a given node. In tree structures, every node can have only one parent, the only exception being the root. The root node has no parent.

Now, if we know how deep our tree will be, using just the parent for information, we are set. If we do not know the depth exactly, things are a bit more complicated. Since people created databases, a lot of storing methods have been born that help store recursive data linearly. Each is different in a way and each is good at something, but bad at other.

Our example is a basic linear representation and is pretty quick. It contains some extra info that some might consider an overhead, but it is simple, logical, and it works.

This is how we store the data. Every row is a node. The columns are as following:

Id: this is the autoincrement unique id of every node.

Parent: This contains one integer, the Id of the parent node. This is mainly formality and is used in simple cases.

Tree: with this field, we can have more than one tree in one table. This is an integer and is the id of the tree we work with. Every tree has a root node that is mandatory

Slug: this is a slug, created from the given name and is always unique in the table. This is an additional unique field besides the Id.

Name: this is the name of the node.

Path: this column coontains the ids of the nodes that are before our node on the branch from the root, merged into a string. This contains the full path from the root till the node. This is handy in building the hierarchy in PHP.

Children: contains all the ids of the children of a node, merged into a string. This also stores the order of the children.

Handling tree in PHP

In PHP, we can easily manipulate this data. We will have some basic examples to show the perks of this type of DB structure.

For start, how do you get the tree? With one simple query, we can get the whole tree, or just a subtree, using the id of the root node. The nodes that have paths that contain the given id, all belong to the same subtree. This looks like this:

SELECT * FROM `table_name` WHERE 
			`path` LIKE "%-:parent-%"
			OR `path` LIKE "%|:parent-%"
			OR `path` LIKE "%-:parent|%"
			OR `path` LIKE "%|:parent|%"

When we have the data, we have to convert the strings into actual PHP arrays for us to be able to easily use them later. We do this like:

$node->path = array_filter(explode('-', str_replace('|', '', $node->path)));
$node->children = array_filter(explode(',', str_replace('|', '', $node->children)));

$node->path = array_filter(explode('-', str_replace('|', '', $node->path)));
$node->children = array_filter(explode(',', str_replace('|', '', $node->children)));

One other important aspect is moving the nodes from a parent to another, being able to move the whole subtree if necessary. In our case this is not hard, we just have to update some strings. In PHP this means slicing and rearranging our arrays of children and path. Something like this:

// Get old parent
$old_parent = $this->getNode($node->parent);
			
$old_parent->children = array_diff($old_parent->children, array($node->id));
$this->_storage->begin_transaction();
			
try
{
	$this->_storage->updateNode($old_parent);
				
	$arr2 = array_slice($to->children, $order-1);
	$arr1 = array_diff($to->children, $arr2);
	$to->children = array_merge($arr1, array($node->id), $arr2);
				
	$this->_storage->updateNode($to);
				
	$node->parent = $to->id;
	$node->path = array_merge($to->path, array($to->id));
	$this->_storage->updateNode($node);
				
	foreach( $subtree as $subnode )
	{
		$subnode->path = array_merge(
			$to->path,
			array($to->id, $node->id),
			array_diff($subnode->path, array_merge($node->path, array($node->id)))
		);
					
		$this->_storage->updateNode($subnode);
	}
				
	$this->_storage->commit_transaction();
				
	return true;
}
catch(Exception $e)
{
	$this->_storage->rollback_transaction();
	$this->_errors['move'] = $e->getMessage();
	return false;
}

Ordering is also easy. Ordering is done on a given level, so we use the children column to order the nodes. The code would look like this:

$children = array_diff($to->children, array($node->id));
$arr2 = array_slice($children, $order-1);
$arr1 = array_diff($children, $arr2);
$to->children = array_merge($arr1, array($node->id), $arr2);
			
$this->_storage->updateNode($to);

Upon deletion, using the move section, you can prompt the user to move the subtree to root, or delete the whole subtree.

Using LIKE syntax in SQL, you can achieve a lot of things.

One last thing that needs mentioning is the recursive function that builds the N depth out of linear data we just got from DB. Here it is:

private function _build_tree(Node $root, $data)
{
	$mapped_node = array(
		'node' => $root,
		'subnodes' => array()
	);
		
	if ( !empty($root->children) )
	{
		foreach( $root->children as $child )
		{
			if ( array_key_exists($child, $data) )
			{
				$mapped_node['subnodes'][] = $this->_build_tree($data[$child], $data);
			}
		}
	}
		
	return $mapped_node;
}

Conclusion

You can find all these pieces of code in the PHPInfinityTree repository on GitLab. This is probably not the best solution, but is simple, understandable and is quick. Since recursivity cannot be used in many databases, we have to store the data linearly. Then we go trough it linearly and build up the tree itself.

You can find a working example on PHPInfinityTree.

Also, you can find the packed and documented package of Infinity Tree in the Store.

If you create a small project, using this technique is totally ok. The problem starts when the project starts to grow.

This article is about a small sized project with very few PHP files. In any case, readability is a very important thing. You know the case when you get back to your code after a long time to edit something, and you just are lost. To make the code readable and logically sound, there is a structure that can be used to achieve it.

If the PHP file contains HTML in it, usually it is good to separate the two. The file starts with PHP, containing all the logic needed. All the data that needs to be printed on the screen is added into variables. These variables are then used in the HTML. This clearly separates the logic from the actual data output. So the structure looks something like:

<?php 
// PHP code here $variable = 'Hello, world'; 
$variable = 'Hello, world!';
?>
<!-- HTML part here -->
<div><?php echo $variable; ?></div>

In the PHP section, where the logic is, you can also separate the logic that handles POST requests for example. It is good practice to create variables that will control such events and that hold information about these events. These variables than can control the HTML part accordingly. For example:

 <?php
$error = '';
$post_var = '';
$was_post = false;
// Some data collecting logic
$variable = 'Hello, world!';
if ($_POST)
{
    $error = 'Sample error.';
    $post_var = 'Goodbye';
    $was_post = true;
}
?>
<?php if ($error != ''): ?>
    <div style="color:red;"><?php echo $error; ?></div>
<?php endif! ?>
<div><?php echo $variable; ?></div>
<?php if ( $was_post ): ?>
    <div><?php echo $post_var; ?></div>
<?php endif; ?>
<form action="" method="post">
    <input type="submit" value="POST">
</form>

This makes your code clear and if needed, later you can separate the logic from the actual html. Using such a structure is beneficial for you. Since PHP is a very loose language, you are the one that needs to pay attention to such things, but you will not regret it.

You will be able to see the latest news, latest tutorials, new products and everything that is related to gardatil programming.

So enjoy, and come back from time to time to see if there is anything new around.

• Self-made code packages;
• Basic SEO;
• Website creation;
• Bugfixes on existing setups;
• Programming help;

• Kohana;
• WordPress;
• PrestaShop;
• Codeigniter;
• CakePHP;
• Aura;
• Yii;
• Laravel