What do we do with all the existing technology?
We have the means but what’s the end? Where are we going?
We probably can solve the problem but have we defined the problem or we just create possible scenarios around the means?
We have huge amounts of data but how good are we at translating that into knowledge?

I tend to agree that these are intermediary times between an, let’s say, Industrial Era and probably an Intelligence Era.
This imagination and innovation age, revolutionary nonetheless, is a great time to live in but when will we put all these amazing discoveries to work towards an end? When we’ll take that moment to properly define the problem so we can come up with the solution?
I think the era of “let’s create some more needs” is very close to its end.
This approach is not feasible in any way, shape or form and the best example is our relation with Nature. We could go micro as well and have a quick look in some offices too.
We definitely need to be much more flexible and agile because if we’re not, Darwin’s words might become our nightmare. Why? Well, because it’s not about the strongest, it’s about the most adaptable, it’s about how fast can you anticipate, understand and adapt.
And if you might be able to anticipate using your imagination, intuition and rationale, in order to understand you need to go back to the essence.
Adaptability is change and means how fast can you learn and put into practice what you’ve just learnt.
That is what makes the difference.
It’s not about systems, it’s not about markets and it’s not about customers. It’s not about micro or macro, it’s about us and the values we use, the perspective we have and the commitment.
Of these values we unfortunately use two sets, the one that we follow when we do, which are the main proof of ones character – many close an eye quite often on these ones – and the other set of values that is used when we expect – this makes us hyper critical.
Solution? Well, going back to the first paragraph I’d say that a return to the essence might help us put the balance right and this way open a new, much wider and clearer perspective. From all these as we know one outcome is a deeper understanding and a much more focused energy. Being in balance, I’d say, we’ll give us that constant and sustainable flow of creative energy that in the end separates us from everything else and even from each other.
Probably this way we’ll have better professionals, better organisations, better society … and definitely, individuals that are survivors and a better relation with what’s around us.

So, 2 cents, the source of inspiration can be the essence of things.
My advice, the essence can( and should) definitely be the source, including the source of inspiration. And the eternal return is the foundation of what can be described as a continuous process of improvement.

If you’d like to add anything to this please use the comments form below.

Thank you

In these series we’ll assume that the reader is familiar with at least some basic Agile concepts as we won’t discuss anything else but how to set up a deployment pipeline, term introduced by Continuous Delivery.

We all know that the demand for quality software at a faster and faster rate is always on an ascending trend and because of that every organization (who understands the challenge and want’s to stay in business) is putting more and more effort to become more and more flexible/adaptable/agile (like in the word agile) adopting methodologies like Lean and Agile.

In our scenario we’ll assume some things and we’ll use some tools or approaches but they are just an example and they might not necessarily represent the ideal set up for all organizations. However it should give you an idea (if you don’t have one already) about how a deployment pipeline might look like, or, if you are already agile it can work for you as an example or as a term of comparison.
Also Continuous Delivery is not only about automation, so when this is about to be put in place a deep investigation must be done as this is also about sales and pricing, about organizational structure and governance system and more.

In our series we’ll try to create a scenario in which a deployment pipeline is being set up for a SME which delivers web solutions. Also the components used in our example are just for testing purposes only and you can use any other component from the same category and rules should still apply (apart from those custom solutions which might need custom settings).

Prerequisites:

• Ubuntu
• Apache
• Apache Tomcat
• Hudson
• Selenium
• Sonar
• Mercurial
• MediaWiki
• MantisBT

The above is a list of tools that will be used and the below is the list of an (maybe Agile) Integrated Development Environment:

• Build Servers
• Source Control
• Development
• Staging
• Production

That being said the introduction should be almost at the end but before we close it we’ll just mention that there will be a few other tools/components that we’ll use in our example and they are as follows (even if as we already mentioned the set up is not necessarily dependant on one or the other):

• CodeIgniter (and Django)
• MySQL Database
• BASH Shell Scripting
• SSH

In Part 2 we’ll start making our hands dirty so hang on.

1
2
3

gconftool-2 --shutdown
rm -rf ~/.gconf/apps/panel
pkill gnome-panel

That’s it.

Enjoy!

1

sudo tasksel

Select LAMP server from the list and hit Ok.
Make sure you follow the installation process to be sure that everything went well but also because you’ll probably be prompted for a root password for MySQL Database server.
This way you don’t need to search for each package and you have the option to install more packages that are usually being used with the LAMP environment (i.e. OpenSSH, PostgreSQL …).
Also please note that not all the modules/extensions/libraries will be installed for a specific package i.e. if you need cURL for PHP you need to install it manually like this:

1

sudo aptitude install php5-curl

The above is pattern is valid for all other packages/modules/extensions/libraries that you might need for existing packages or for new packages like Version Control Systems.
Enjoy!

1

uname -a

A good one but not everyone is a techie so you’ll need to give them something that can be pronounced and is more comercial than the output of the above command.
For some Linux distros you can also use these commands (in conjunction with the above):

1
2
3
4

# Debian based distros - i.e. Ubuntu
lsb_release -a
# Redhat based distros - i.e. Fedora, CentOs
cat /etc/redhat-release

This way you get the commercial name of your distro.
Enjoy!

Beautiful is better than ugly.
Explicit is better than implicit.
Simple is better than complex.
Complex is better than complicated.
Flat is better than nested.
Sparse is better than dense.
Readability counts.
Special cases aren’t special enough to break the rules.
Although practicality beats purity.
Errors should never pass silently.
Unless explicitly silenced.
In the face of ambiguity, refuse the temptation to guess.
There should be one– and preferably only one –obvious way to do it.
Although that way may not be obvious at first unless you’re Dutch.
Now is better than never.
Although never is often better than *right* now.
If the implementation is hard to explain, it’s a bad idea.
If the implementation is easy to explain, it may be a good idea.
Namespaces are one honking great idea — let’s do more of those!

Link: The Zen of Python

Enjoy!

1
2
3
4
5
6
7
8
9
10

<IfModule mod_rewrite.c>
RewriteEngine On
RewriteBase /
RewriteCond %{REMOTE_ADDR} !^12\.23\.34\.45$     
# If you want to add more IP's add OR 
# at the end of the previous line like below
# RewriteCond %{REMOTE_ADDR} ^12\.23\.34\.45$ [OR]
# Make sure your file exists
RewriteRule !^maintenance /maintenance.html [R=302,L]
</IfModule>

That’s it. Make sure you add this code to your .htaccess file and you have maintenance.html in the same folder with .htaccess. This relies on a web server setting that allows the server to read the .htaccess file. If that is there then everything should be just fine.
Enjoy!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 
class Application extends Controller {
 
	private static $results_per_page = 15;
	private $terms = array(); // default empty search terms array
 
/**
 *
 * Here goes your function description
 *
*/	
	function __construct(){
 
		parent::Controller();
		$this->results_per_page = self::$results_per_page;
		$this->load->model('Application_model');
 
	}
 
/**
 *
 * Here goes your function description
 *
*/	
	function index(){
 
		$this->search();
 
	}
 
/**
 *
 * Here goes your function description
 *
*/
	function search(){
 
		if( ! isset($_POST['submit']) ){
 
			// reset the search terms
			$this->session->unset_userdata('s_key_one');
			$this->session->unset_userdata('s_key_two');
			$this->session->unset_userdata('s_key_three');
 
			// application_search is our view that contains the form
			$this->load->view('application_search');
 
		}
		else {
 
			// this is how it works if you store your validation rules in a file
			// if you do, good, if not, make sure that you have a file that contains your
			// validation rules in a format that can be found in CI's user guide
			$this->config->load('form_validation', TRUE);
			$this->form_validation->set_rules($this->config->item('application', 'form_validation'));
 
			if ($this->form_validation->run('application') == FALSE){
 
				$this->load->view('application_search');
 
			}
			else {
 
				$this->terms['s_key_one'] = $this->input->post('key_one');
				$this->terms['s_key_two'] = $this->input->post('key_two');
				$this->terms['s_key_three'] = $this->input->post('key_three');
 
				$this->session->set_userdata($this->terms);
 
				redirect('application/view');
 
			}
 
		}
 
	}
 
/**
 *
 * Here goes your function description
 *
*/
	function view(){
 
		$this->load->library('pagination');
 
		$offset = $this->uri->segment(3, 0);
		$total = $this->Application_model->count_all();
		$data['results'] = $this->Application_model->get_all($this->results_per_page, $offset);
 
		$data['total_rows'] = $total;
 
		$config['base_url'] = base_url() . 'application/view';
		$config['total_rows'] = $total;
		$config['per_page'] = $this->results_per_page;
		$config['uri_segment'] = 3;
		$config['num_links'] = 3;
 
		$this->pagination->initialize($config);
 
		$data['page_links'] = $this->pagination->create_links();
 
		// application_view is our results page
		$this->load->view('application_view', $data);
 
	}
 
}
 
/* End of file application.php */
/* Location: ./system/application/controllers/application.php */

As you probably already saw we have the class properties $results_per_page which is static as will contain the value of how many results will be displayed per page. We have also an empty array $terms that will contain the search terms from the form.
Inside the controller we have only a few methods, probably you’ll have more than that but for the sake of this article we’ll display only the ones that are needed by the search system.
The default method, index(), will only load the search method. For the search you need a view (we called our view application_search), a view that will contain the form.
The method will process the form is submit button was pressed if not will reset the session values for every search term. You can use this space to re-populate the search form if needed.
If the submit button was pressed then the form will be processed. As you see inside the code we assumed that you store your validation rules inside a form_validation file.
If everything goes well you build the $this->terms array and based on which you create the session search keys and you redirect your search to the view method.
Now you can display all your results without having any search term displayed in the url. Depending on your requirements you could use flashdata.
The view is extremely simple so will not stay to much on it.
What is very important is the model. And here it is:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

<?php if ( ! defined('BASEPATH')) exit('No direct script access allowed');
 
class Application_model extends Model {
 
	private $s_key_one = FALSE;
	private $s_key_two = FALSE;
	private $s_key_three = FALSE;
	private static $search_terms = array('s_key_one', 's_key_two', 's_key_three');
 
/**
 *
 * Here goes your function description
 *
*/	
	function __construct(){
 
		parent::Model();
		$this->search_terms = self::$search_terms;
		$this->_check_search_session();
 
	}
 
/**
 *
 * Here goes your function description
 *
*/	
	function _check_search_session(){
 
		foreach($this->search_terms as $key => $val){
 
			$chk = $this->session->userdata($val);
			if($chk !== FALSE){
 
				if(empty($chk)){
 
					$this->$val = FALSE;
 
				}
				else {
 
					$this->$val = $chk;
 
				}
				unset($chk);
 
			}
 
		}
 
	}
 
/**
 *
 * Here goes your function description
 *
*/	
	function _filter(){
 
		if($this->s_key_one !== FALSE){
 
			$this->db->where(" applications.key_one = " . $this->s_key_one . " ");
 
		}
 
		if($this->s_key_two !== FALSE){
 
			$this->db->where(" applications.key_two LIKE('%" . $this->s_key_two . "%') ");
 
		}
 
		if($this->s_key_three !== FALSE){
 
			$this->db->where(" DATE(applications.key_three) >= DATE(FROM_UNIXTIME(" . strtotime($this->s_key_three . ' 00:00:00') . ")) ");
 
		}
 
	}
 
/**
 *
 * Here goes your function description
 *
*/	
	function count_all(){
 
		$this->db->select("applications.id");
 
		$this->_filter();
 
		$query = $this->db->get("applications");
 
		return $query->num_rows();
 
	}
 
/**
 *
 * Here goes your function description
 *
*/
	function get_all($limit, $offset){
 
		$this->db->select("applications.*");
 
		$this->_filter();
 
		$this->db->order_by("applications.id", "DESC"); 
		$this->db->limit($limit, $offset);
		$query = $this->db->get("applications");
 
		if($query->num_rows() > 0){
 
 
			return $query->result();
 
		}
		return FALSE;
 
	}
 
}
 
/* End of file application_model.php */
/* Location: ./system/application/models/application_model.php */

Similar to the controller you’ll declare a few properties which are the search keys from your session. Also you need to declare an array having the same values. You’ll make a loop based on this array checking for the existence of each key in the session. This is what _check_search_session() does.
Also we’ve placed all the filters in a separate function. That way you have the flexibility to build your rules. We call the function inside the count_all() and get_all().
This is it. You can do a lot with this piece code what we tried here was to show a different approach.
If you need more details please leave a message.
Enjoy!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

$sql = "UPDATE 
		t1 
	LEFT JOIN 
		t2
		ON 
		t2.a = t1.a 
	SET 
		t1.b = ?, 
		t1.c = ?, 
		t2.d = ?, 
		t2.e = ? 
	WHERE 
		t1.f = ? 
	AND 
		t1.g = ? 
	;";
 
$query = $this->db->query($sql, array($t1b, $t1c, $t2d, $t2e, $t1f, $t1g));

It was easy, wasn’t it?
I hope this helps. If you have any more questions don’t hesitate to leave a message.
Enjoy.