dkeats.com

First you need to install the shorturl module. Copy the _htaccess file in the short URL module to the root of your Chisimba site as .htaccess (note the dot replacing the underscore). Enable mod_rewrite in Apache by typing 'sudo a2enmod rewrite' into a terminal. Then you need to tell apache to allow overriding paths by editing /etc/apache2/sites-enabled/000-default (or the file for your particular vhost) and adding 'AllowOverride All' to <Directory> section of the file (see image, click for larger version).

After you restart apache using 'service apache2 restart', you should be good to go. Short URL appears on the admin menu of your Chisimba site. This is a manual system of managing short URLs, you can type any URL into the editor, and a short version of it.

Here are a couple on  this site:

• http://dkeats.com/makecourse
• http://dkeats.com/cleanslate

There are other ways to do short URLs in Chisimba, but this is the one I prefer. There is also a proposal for a more permanant system of short URLs at http://dkeats.com/staticurl - but this has not yet been implemented.

It is not uncommon to move installed web applications between different physical or virtual servers. This is really a basic systems administrator task, and is not particularly special to Chisimba. Any systems administrator should know how to do this for any web appliation.

In this example, we will be moving an installation from one server to another, but the other server will still be running the same domain. For example, I moved this site from one cloud host to another, and then later moved it again. Before you begin, make sure that you have all teh chisimba files in the correct location on the new server. You can run the install-production-rackspace script, but not bother doing the actual Chisimba install in your browser. This is the procedure I used.

STEP 1. Back up the files you need to copy over.

cd /path/to/your/site (e.g. cd /var/sites/dkcom)

tar -zcf config.tar.gz config
tar -zcf usrfiles.tar.gz usrfiles
tar -zcf user_images.tar.gz user_images

STEP 2. Copy the files over to the new server using scp (secure copy)

scp config.tar.gz config root@yourdomain.com:/path/to/your/siteon/the/newhost

For example, this may be:

scp config.tar.gz config root@yourdomain.com:/var/sites/dkcom/
scp usrfiles.tar.gz config root@yourdomain.com:/var/sites/dkcom/
scp user_images.tar.gz config root@yourdomain.com:/var/sites/dkcom/

If you have a .htaccess file, you can also scp that over, for example if you run a URL shortner.

scp .htaccess config root@yourdomain.com:/var/sites/dkcom/

STEP 3. SSH into the new server and unzip them

cd /var/sites/dkcom
touch tmpinstallfile
rm installer -R

tar -zxf config.tar.gz config
tar -zxf usrfiles.tar.gz usrfiles
tar -zxf user_images.tar.gz user_images

STEP 4. Back up and restore the database

Assuming you have PHPMYADMIN installed on your original and destination servers, EXPORT your database as an SQL file, and save it to your local computer. Then open PHPMYADMIN on the destination server, and import it. Make sure that your PHP.INI settings are adequate to allow a fairly large file upload, or the import will fail.

That's it. If the DNS has propagated, open your site via its original URL on the new server and it should all be there. A word of caution though, when I did this for dkeats.com, it looked as though the ipaddress change had propagated, but I was working away on the old site! It is probably a good idea to replace index.php on the old site with something that will let you know that you are on the wrong site just in case.

Another note. If you are moving between domains, you can follow the same procedure, but you will need to use SED to change all occurrences of originaldomain.tld in the SQL file to newdomain.tld. Google 'SED command line editor' for how to do that.

I was recently queried about FOSS and innovation.  The question was:

However, before we get to why the answer is 'no', let us look at these questions that, on the surface, appear to be related even though they are independent. This type of question is one of a class of fallacies known as 'fallacies of distraction' and it is an instance of the 'complex question fallacy'. This type of question is seldom asked out of ignorance, it is almost always use by someone with malicious intent. There are two parts to the question, with the implicit idea being that if the answer to the second question is 'no' then the conclusion should be that FOSS does not foster innovation. FOSS activists should be aware of this type of fallacy, as it is a common ploy that is often used along with the red herring and the straw man fallacies when the person using it wishes to discredit FOSS before a naive audience.

Innovation is subject to suvivorship bias (you don't see the graveyard of failed innovations, only the successful ones that survive and still exist), and 'luck' plays a strong role. Furthermore, innovation is likely to be scale dependent, with an inverse probability of success as one goes up in scale. In addition, innovation is not static, and it is subject to the fact that the past is not a good predictor of the future (something that is axiomatic since something predictable is unlikely to be innovation - See 'The Black Swan' by Nassim Nicholas Taleb). For these reasons, but especially the suvivorship bias, it is almost impossible to make meaningful studies of innovation or draw meaningful conclusions.

To my knowledge nobody has ever claimed anything about FOSS being 'most innovative'. Indeed, innovative is perhaps not so much a characteristic of software, but rather of people and perhaps to some extent organisations. There are, however, certain barriers to innovation that FOSS reduces or eliminates, and this allows people to innovate. There are other barriers that affect innovation, such as access to capital for example, that are not impacted directly by FOSS. Most of these barriers are self-evident and obvious, rather like the statement that an open door is easier to pass through than a closed door. Some of the barriers inherent in proprietary software that FOSS lowers or eliminates include:

Availability of starting points Access to knowledge Software Permissions Software and other initial and ongoing costs

One of the great things about working in a FOSS ecosystem is that one seldom has to start from scratch. there is a wide variety of software available in different layers from the operating system, programming languages and tools, web server, database, components and full applications. These can be used without any requirement to do anything in particular, including ask for permissions because those permissions are explicitly given in the license. For example, when we started Chisimba as part of the African Virtual Open Initiatives and Resources (AVOIR) project, we built it on the GNU/Linux operating systen, the Apache web server, the PHP programming language, as well as a large number of other building blocks that went into it.

Access to knowledge is a key component of how FOSS lowers the barriers to innovation. When you have an idea, limited coding experience, and few resources, how do you learn to code it? Excellent software is available to study, and if in studying it you use it for something, that is OK, because the freedoms of Free Sofware mean you are free to study, adapt, modify and distribute. Free Software as a learning resource not just because its source is available, but because often the source has been designed or developed by some of the best programmers in the world. Aside from the source code, the community associated with most FOSS projects is itself a learning resource, especially for those willing to jump on the mailing list and ask informed questions.

Software and other initial and ongoing costs are reduced by using FOSS. There are a number of cost areas that are impacted by FOSS including:

• Start-up costs;
• Scaling out costs;
• Lock-in costs;
• Maleability costs;
• Abandonment costs;
• Uncertainty of costs.

With FOSS, you can just grab the building blocks and development environment you need, and get started. Whether you have one developer or many, the cost of these building blocks is the same: nil. When you want to scale out, you do not have to worry about purchasing additional licenses, you just do it. There are no lock-in costs, and where there are alternative technologies to use, it is usually pretty simple to change. There are no proprietary lock-in mechanisms in FOSS. One of the costs that is often overlooked is what I call maleability costs. When you are starting something, you often want to try out different application stacks and ways of doing something. ... Then there is the uncertainty of what you will need if your application needs to scale, and predicting future costs for complicated, proprietary licenses is almost impossible.

	Many of the most innovative and valuable companies today got started by building on this stack of existing FOSS applications, including Google, Facebook, Twitter, and others. Google was founded by Larry Page and Sergey Brin while they were students at Stanford University. They maxed out their credit cards to buy hardware, and would certainly not have been able to have gotten the company off the ground if they needed to worry about software license fees and the general uncertainty of proprietary license mindfields. Google became a private company on September 4, 1998, and Larry & Sergey made #5 on Forbes list in 1997 with a net worth of $18.5 billion each.
	Another Ingernet success story is Facebook launched by Mark Zuckerberg from his Harvard University dorm room on February 4, 2004. Facebook was built entirely on a FOSS application stack, mainly because the lack of barriers allowed Zuckerberg and his friends to just experiment. After he built a global company on a FOSS platform, Time magazine named Zuckerberg as one of The World's Most Influential People of 2008, with Facebook being ascribed a Market value of $15 billion in 2007. Faceook continues to contribute to FOSS, and has recently also published open hardware specifications for its data centre hardware.
	Closer to home in South Africa, when Mark Shuttleworth started Thawte in the 1990s, originally run from his parents' garage in Durbanville. He built the applications on a stack of existing FOSS applications, with the secure server being an adaptation of the Apache web server server. Before being sold, Thawte captured 50% of the world's digital certificate market, with VeriSign having the other half. In 1999 VeriSign acquired Thawte in a stock purchase from Shuttleworth for US$575 million.

Lowing the barriers to innovation is the basis for Dr Sibusisu Sibisi's discussion on FOSS (as FLOSS) and national innovation systems in the NACI document. It is well worth a read. On page 7, the point is made that by expanding the scope for local innovation, an open source development environment allows local enterprises both to germinate, and to move up the international ICT knowledge value chain. This is only possible because the barriers are lower.

Vint Cerf, one of the co-creators of TCP/IP that powers the Internet, gave a recorded video at the Digital Freedom Expo in Cape Town a few years ago, and he pointed out how the importance of keeping TCP/IP free had led to the innovations that we now collectively know as the Internet. "Keeping important things Free and Open has been vital to the development of the Internet, and is likely to be an valuable contributor to development in Africa because when core things are Free and Open there are no barriers to innovation." We can look at this effect in the chain of things that led to the creation of Google, and its expansion as a global company.

The Austrian-American economist Joseph Schumpeter is responsible for many of the ways we think about innovation. Schumpeter postulated innovation as a critical dimension of economic change, and argued that innovation was substantially if not exclusively the purvey of the firm. He argued that temporary monopolies were necessary to provide the incentive necessary for firms to develop new products and processes. More recently, Eric von Hippel -- is a professor at the MIT Sloan School of Management specializing in the nature and economics of distributed and open innovation -- has provided an alternative view of innovation. von Hippel developed the concept of user innovation – that end-users, rather than manufacturers, are responsible for a large amount of new innovation. In von Hippel's view, individuals, firms (where software is not their main product) and organisations can all be 'user innovators'. By virtue of the lower barriers, in software space, FOSS is a major contributer to user innovation and this is the subject of a body of empirical research by von Hippel and his students. Schumpeterian innovation.

One of the consequences is that nearly all of the innovative IT-based companies of the last 10 years have been built on FOSS. The small few that have not were created by companies which already had a large investment in proprietary technology (so could eliminate their own barriers), or were funded by them. A relatively few do not fit into these categories. However, these results are also obviously subject to survivorship bias, so other than observation, one really cannot draw 'because' conclusions from them.

This is the third howto video about using Chisimba in eLearning. This one gives you a brief overview of using the built-in content creation tools inside a course.

The Kenga Solutions team are pleased to release version 3.3.1 of the Chisimba core framework. This is a heavily tested version of Chisimba, and the first release in over a year. It provides for numerous bug fixes, and enhancements. Most development during the past 2 years has been outside the core, in the modules (packages), a stable release of which will be made during the coming weeks.

To install Chisimba 3.3.1 on Ubuntu, proceed as follows.

If you do not yet have Apache, MySQL and all the required libraries, run the following commands in a terminal:

sudo apt-get install subversion apache2 mysql-server mysql-client php5 php5-mysql php5-imap php5-gd php5-curl php-pear php5-imagick php5-imap php5-ldap php5-mapscript php5-mcrypt php5-memcache php5-mysql php5-pgsql php5-pspell php5-snmp php5-sqlite php5-tidy php5-uuid php5-xmlrpc php5-xsl

sudo pear channel-update pear.php.net
sudo pear upgrade pear
sudo pear upgrade-all
sudo pear install --alldeps -f Config Log
sudo pear install MDB2
sudo pear install MDB2_Driver_mysql
sudo pear install MDB2_Driver_pgsql
sudo pear install MDB2_Driver_mysqli
sudo pear install  --alldeps -f  MDB2_Schema

Then do the following:

1. wget http://kengasolutions.com/usrfiles/users/6258120112/releases/chisimba_3.3.1.tar.gz
2. Unzip in the web root or a directory of your choice (e.g. var/www/chisimba)
3. Open http://site.domain.tld/chisimba in your browser

Install as per the instructions in the browser.

NOTE: There is as yet no stable install for modules (packages). You will either have to install them from a subversion checkout, or use the built-in module catalougue to install them over the web. A stable package server will be available for this in about 10 days (or sooner), meanwhile, module catalogue points to chisimba.com which has the subversion files in a package server.

The control panel is one of the first tools you need to get to know after you create a course in an eLearning instance of Chisimba. The video below will take you through the basics of the control panel for your course.

Chisimba had powerful eLearning tools. With Chisimba, you can have a cloud-based eLearning site up and running in <10 minutes, and your first course online about a minute after that. The video below shows how to create your first course, assuming you already have as site up and running.

My talk given at the Idlelo5 conference in Abuja, Nigeria, March 20th 2012.

This howto will show you how to use the Clean Slate module in Chisimba to create a quick and simple interface to functionality and content for a site. This module is for site owners, not general users, but it enables the quick creation of a unique interface on a particular site, including multiple pages.

Here is a video of the talk I did about the AVOIR (African Virtual Open Initiatives and Resources) project at the Digital Freedom Exposition, held at the University of the Western Cape in Cape Town in April 2007. One of the many dreams I have is to rebuild something like AVOIR to help promote sofware engineering based on Free Software (open source) in Africa. AVOIR or an AVOIR-like initiative could also raise understanding of the concepts of digital freedom, idea capital (or software colonialism as a colleague calls it), as well as promoting the free sharing of knowledge and ideas about technology to help contribute to development and the achievement of some of the millenium development goals.

With synergy, we can do anything.

My company, Kenga, provides development and support services for Chisimba, which I think is the only made in Africa Free Software (open source) development framework. We host our sites and our development environment in public cloud, mostly with Rackspace. We have, however, started to experiment with a new cloud provider called Digital Ocean. They are a New York City based startup, and have a good model that seems like it would work well for the SMME sector, as they charge a fixed rate and don't charge for bandwidth. This also seemed good for me, for my personal dkeats.com site, so when I moved it from Paul Scott's infrastructure, I moved it there. I was down for nearly two weeks in this process as I had to figure out a lot of things, including how to recover my own domain name from a previous service provider.

Yesterday, this site went down when I attempted to upgrade the virtual server from 256 to 512 Mb of RAM to cater for an inrease in traffic (hopefully people reading this blog, not hackers!!).  Nothing I tried would bring it back, there was a bug in the Digital Ocean ticket system, there was no other way to contact them, so I panicked and moved a lot of stuff back onto Rackspace. The one thing I like about Rackspace is that they have fanatical customer service, the best I have ever encountered from any company anywhere in the world.

I made lots of rants about fly-by-night cloud operators, but actually Digital Ocean is a startup. Kenga is also a startup. Startups need to support one another, so we can get over the hump together. So I will stick with them, keep dkeats.com there, and a couple of other sites, and hope for the best. I will also continue to use them for short-life demo sites that are less mission critical.  Most importantly, the http://idlelo.kengasolutions.com site is there, and we are using that for three days of Chisimba training in Abuja, Nigeria next week. Hold thumbs!!

It turns out that there was an issue with Grub in the version of Ubuntu that they were using in their images. dkeats.com was the only virtual server that I had not upgraded to Ubuntu 11.10, and the only one that I have rebooted, but I am not going to dare upgrading dkeats.com now until I get the fix for the grub issue.

Just thought I would post this to explain the downtime on this site yesterday, as well as to show just how much a geek I am!

Speaking of clouds, here is a time lapse video I made last year of clouds over Johannesburg.

Happy hacking, as RMS says....

Fundamental to good FOSS projects and academic work is the concept of peer review, others with similar interests and backgrounds taking a look at your work and helping to improve it.  Both FOSS and academic work are quality-assured by peer review, sometimes formally and sometimes informally.

Both academics and FOSS practioners share knowledge through collaboration in communities of practice. In these communities, the participants are allocated merit based on their contribution of outputs and their work in the community. A researcher who writes lots of papers in good journals, or a developer who writes lots of really good source code will both be highly respected. They will be respected even more if they take part in the formal and informal activities of their communities.

FOSS developers share software source code through repositories and ideas through mailing lists, while academics share actual lab protocols and other knowdedge through exchange visits, sabbaticals and increasingly to online communities that are not unlike those of FOSS developers.

FOSS developres collaborate through joint contributions to source code, while academics collaborate through joint research and publication. While the details are different, the principles are quite similar in both. I know this because I have been an active and highly collaborative researcher who has published over 80 publications, and I have been an active developer who has contributed source code to FOSS projects. I see no obvious difference between the two kinds of collaboration, other than the objects around which the collaboration happens.

Both academic work and FOSS development thrive on open communication among peers. To me, who works in both, there is little difference between sending an email to Bill Woelkerling in Australia and asking if he thinks my coralline algal specimen is Hydrolithon nased on the coceptacle photograph, and sending an email to a developer list asking if anyone can think of a way to use jQuery to manipulate embedded Flickr images after the page has loaded. The principle of open sharing is common to both.

Coralline algal conceptacle of Hydrolithon	Snippet of code to process a Flickr image after the page loads

Both academics and FOSS developers building on the work of others made publicly available. For developers, this may include the actual source code, whereas with academics such editing would be called plagiarism, although in the world of Free and Open Educational Resources, editing content can also be done for academic purposes.

Both FOSS practioners and academics engage in the mentoring of novices. For academics, this includes the supervision of graduate students and assisting junior colleagues. For developers, a wider variety of mentoring options are available.

Finally, both developers and academics claim freedom, for developers it is software freedom, while for academics it is academic freedom. Software freedom involves the freedom of software users (including other developers) to access the software and do things with it, excercising their freedom of choice within certain constraints. Academic freedom has many definitions, one of them being the freedom of inquiry. Also linked to academic freedom is the idea of being free to teach or communicate ideas or facts without being targeted for repression, job loss, or imprisonment. Software freedom advocates are often academics, and use academic freedom to speak about software. The chief difference is that software freedom can be protected by licenses, while academic freedom and its bounds are contested areas.

In another post, I will look at the implications of software freedom in more detail using a graphic example of the difference between free and proprietary software.

I was recently queried about whether FOSS trumps proprietary software, which to me is a question that is difficult to answer out of context. The question was:

The word 'trump' has so many potential interpretations and I am uncertain what was implied by it, and it is the kind of question that is often associated with bouts of  FUD (fear, unvertainty and doubt). But it was a question that has been asked, so I will try to offer an answer. If anyone has any other ideas to help answer it, please comment or leave them in the Facebook comment block that you will see if you open this post on its own.

An important aspect of this question is the use of the term 'a priori', something which can be generally considered as known 'before the fact' and independent of experience.  The opposite, 'a posteriori' knowledge or justification makes reference to experience. Here I will interpret 'a priori' as equating to something that is generally known, and for which he evidence is well established. The word "trump" derives from "trionfi" or "triumph" so by 'trumps', I will interpret it to mean 'is significantly better than'.

Taking the general interpretation then, perhaps the question means to ask 'Is there a priori evidence that ALL FOSS is better than ALL PROPRIETARY software'. Nobody has, to my knowledge, made such a claim in the abstract. There is some really terrible FOSS software, and some really great FOSS software. There are some really terrible proprietary systems and some really great ones. While it has been shown from source code analysis and other research techniques that FOSS does tend to lead to higher quality code (to the very extent that this is measurable with source code being secret for most proprietary software), I doubt that you could progress from the particular to the general in this way.

There is another way to look at this, and that is from the perspective of a FOSS ecosystem. A FOSS ecosystem consists of the following:

• A large number of FOSS software tools and projects
• The communities that support them, including a large number of private sector companies, institutions, and individuals
• The people within the institution who can do one or more of the following: create, modify, install, adopt, document, train or use FOSS tools
• The maturity of an organisation towards FOSS tools and projects, as well as its processes for selecting software for its use, including the FOSS-friendliness of its prucurement policies, processes and practices
• Companies that provide support and possibly 'value-added' services around FOSS technologies.
   

So the question might mean, generally speaking, is a FOSS approach better than a proprietary approach. The answer, once again, cannot be given out of context, because it depends on the degree to which an organisation has established its ecosystem, in other words its FOSS readiness. ElHag & Abushama [1] charactarise maturity a number of areas, including human, technical and general readiness factors.

In the abstract, I would argue that a FOSS approach is better for institutions in general, but as someone responsible for IT in an institution, there will always be cases that taken in context will demand a proprietary approach or solution. Where FOSS and proprietary integrate best is when the architecture of the applications allow them to be integrated, and this is best achieved through a services orientation and adherence to open standards. An important aspect of why I believe FOSS 'trumps' for institutions is the avoidance of vendor-lockin, and the financial and other damage caused by forced upgrade paths.

If an organisation creates a FOSS ecosystem, it is likely to have at least as good a quality source code, AND it will be free from the kind of vendor damage that is not uncommon with large license vendors. Anyone who has been responsible for IT in an organisation is well familiar with vendor damage. Of course, this will only remain true as long as the organisation does its best to stay on that path and ensure that it creates plenty of synergy. The minute it fails to create synergy, and falls into a silo mode, many of the most valuable benefits of FOSS will be lost.

If the idea of 'TRUMPS' refers to existing applications, then there are some where the FOSS version is better, there are some where the proprietary application is better, purely in terms of fitness for achieving its intended purpose.

But even the word 'better' is itself context sensitive and subjective. For example, I use the Gimp, which to me is better than Photoshop (which I have used for many years), even though Gimp does not have all the features of Photoshop. I can install Gimp on as many computers as I want a few clicks on my software's package management system. For me, Gimp definitely trumps Photoshop. However, there are lots of people who would say the opposite, despite the need to spend substantial money to obtain permissions to install it and the more difficult installation procedure. These different views are irreconscilable, as they relate to personal preference and what will satisfy an individual's need and provide for other components of satisfaction.

For an institution, where vendor damage and excessive upgrade costs are so common, there is absolutely no doubt whatsoever that building a FOSS ecosystem TRUMPS building a proprietary one. But of course, like all ecosystems, there will be flow among them, and FOSS and proprietary technologies will be with institutions for the foreseeable future, and institutions just have to have people who are smart enough to know when to make appropriate choices. Let me repeat this: institutions just have to have people who are smart enough to know when to make appropriate choices.

For me personally and professionally, FOSS trumps almost all proprietary technologies. I have used almost nothing else for the past 11  years, and I still have not developed flesh eating bacteria, had fingers fall off due to leprosy, or been unable to do something that I have needed to do with my computer. And I have not spent a penny on software, nor have I had to deal with virus infestations.

ATTRIBUTION: This article makes use of

• http://en.wikipedia.org/wiki/A_priori_and_a_posteriori
• http://en.wikipedia.org/wiki/Trump

REFERENCES

ElHag, H.M.A. & Abushama, (undated) Migration to FOSS: Readiness and Challenges. http://www.itrc.sd/foss/papers/Migration%20to%20FOSS_%20Readiness%20and%20Challenges.pdf

For me, as an individual user of FOSS desktop systems, the answer is definitely "yes" and most emphatically so. I use an operating system that is without cost to me, I use office software (word processor, database, vector drawing, presentation, spreadsheet) that is definitely without cost. I use an awesome graphics application called 'the GIMP' that is without cost. I watch videos and listen to music using applications that are without cost to me. I browse the web on software that is without cost to me. I create animations and videos using a variety of software tools that are without cost to me. I manage my extensive photo collection using software that is without cost to me.  I do software development as a hobby, and all the tools I use for development are without cost to me. My daughter uses the same system, and plays games that are without cost to her, and also does her school work with software that has no cost. Indeed, there is almost nothing that I can think of that I need to do for fun or work that would require me to pay a software license fee. So, yes, for me as an individual, FOSS is certainly without cost. Indeed, I once make a mapping of the software I use against proprietary packages, and I have in excess of R300 000 worth of software (based on full commercial prices) on my computer, for free.

Layers in a FOSS
ecosystem.

If we look at the diagram left, we can see a stack of different ways of using or working with FOSS. While actual costs are case specific, there would be a reasonable expectation of increasing costs as one moves higher in these layers.

Thus, the reason the cost to my daughter and I is zero is that we are able to use existing software, as is, in the form in which it is supplied. This is the most trivial way in which software is deployed, although it is an important one. Most real problems in large organizations cannot be solved using simple deployment of software as is, with no customization. This applies to both FOSS and proprietary software.

In a typical, large software project, licenses are an important and recurring cost, but do not generally consititute more than 25% of a typical project implementation, often less. Thus, the cost of implementation of large systems will be similar for both proprietary and FOSS systems, unless one area requires more customized code to be written than the other. This cannot be addressed in the abstract, however, the desire of the ignorant notwithstanding.

A very important cost impact of proprietary licenses lies in vendor lock-in and consequent exit costs. Exit cost for proprietary software can be so significant that organizations may be reluctant to exit even when there are compelling reasons to do so. The cost of Wits exiting the Oracle Student System, a typical proprietary, tightly coupled system are likely to be double digits, without even including the costs of implementing the alternative solution. Let me say that again, because it is so often overlooked: the exit costs are huge, and the time pressure adds additional costs and constrains our choices severely.

There will be times when a FOSS solution to a given problem will be more expensive than a proprietary solution when taken from the perspective of a particular project. However, measured in terms of contribution to building a broader ecosystem, such extra costs may be justified; or they may not be. Decisions in this case will require a full examination of the costs and benefits, both long and short term, and an application of wise minds - just as you have to do with any software project whether based on FOSS or proprietary software.

When an organization is undergoing change from predominantly proprietary to substantially FOSS (for example), there will be a typical change or pain curve. It may cost more in the short term to implement FOSS than to go with the 'standard' proprietary solutions. Sometimes - due to lack of understanding of the nature of pain curves - organizations change back to the old way before they have emerged from the pain curve, and never realised the long term value of building a FOSS ecosystem.

When you measure the total cost over the life of a system, in general FOSS should come out cheaper, but there is no general guarantee that this will be true in the abstract. Most costs in a software project are part of implementation, and it is possible to have very expensive implementations of either a FOSS or a proprietary technology. The cost impact will be determined by the degree to which you have created or have access to an ecosystem of support. This ecosystem will consist of:

• internal skills
• companies providing support
• local and global communities.

Over time, with adequate support, FOSS will reduce costs for most areas. However, there will be some for which it will not. Therefore, it is vital to evaluate each case on merit and to do so skillfully and with knowledge and understanding of all the nuances. In this respect, FOSS is no different from any other technology acquisition. It is certainly not costless. And how much it reduces costs will be highly dependent on what you do with it. You might, for example, discover that you can innovate more with FOSS and achive higher value, and therefore your costs may increase along with value.

Indeed, the notion of cost in the abstract is not really very useful. There are a number of business models for FOSS in an organization, and they are all different, with different cost impacts, and the costs vary with the nature of the project, the availability of in-house skills, the degree to which the principles are understood and embraced, and the availability of external resources that can be called on when needed.

The same range of business models is true for proprietary software, so the only way to compare costs is to have exactly identical projects under exactly identical conditions. In such a situation, FOSS should be somewhat to significantly less costly because it lacks the license fee. However, such a situation is almost impossible to imagine creating in reality, so discussions of costs in the abstract are really a distraction. Until you have an actual project, and its implementation ecosystem, cost is not something that you can meaningfully consider.

I have always maintained that any savings from implementing FOSS are collateral benefit, the metaphorical cherry on the cake. Likewise, the Joint Information Systems Committee (JISC) of the UK concluded that the real value of FOSS arise out of the options and flexibility that it brings. They conclude:

In fact, the real value of OSS is that it makes it possible for you to exercise control over how you run your institution's IT department by allowing you to choose a model from on any point on the spectrum that runs from fully self-supporting to fully outsourced. In turn, this allows institutions to choose the extent to which they want, and are able to, take advantage of the strategic organisational  gains that accrue from the use of open data standards and open source software.

http://www.oss-watch.ac.uk/resources/procurement-infopack.xml#ixzz0r0KMuovv
Under Creative Commons License: Attribution Share Alike

My main point here is that whether FOSS is without cost or not depends very much on particular cases. Cost is one side of the cost-benefit equation. Value arises when benefits are greater than costs. Whether this is true for any given software project is not a function of FOSS versus proprietary, but how well you execute the project, and how long you can sustain the benefits. The question of cost is meaningless in the abstract, though very important nevertheless.

If you install Chisimba on a production site, there are some security measures that should be taken at the level of the server it is running on as a means to reduce security risks. One of these is to disable directory listings. This is done in the sites-available file on Apache in Ubuntu 11.04 or 11.10.

This file has the following structure:

<VirtualHost *:80>
    ServerAdmin webmaster@localhost

    DocumentRoot /var/www
    <Directory />
        Options FollowSymLinks
        AllowOverride All
    </Directory>
    <Directory /var/www/>
        Options Indexes FollowSymLinks MultiViews
        AllowOverride All
        Order allow,deny
        allow from all
    </Directory>

    ScriptAlias /cgi-bin/ /usr/lib/cgi-bin/
    <Directory "/usr/lib/cgi-bin">
        AllowOverride None
        Options +ExecCGI -MultiViews +SymLinksIfOwnerMatch
        Order allow,deny
        Allow from all
    </Directory>

</VirtualHost>
 

All that is necessary is to delete the word Indexes as highlighted in red above, save the file. Repeat this for any other virtual hosts you have, and restart Apache.
 

I had an interesting conversation with Charles Majola yesterday about static urls in Chisimba. He was unable to get a client to use Chisimba because of the fact that there are only dynamic URLs available. While this is not quite true as there are at least three different URL rewriting tools in Chisimba, the automatic rewriting of URLs has never been done. Possibly there are two reasons for this:

•  we have not had a major use for it, so nobody did it;
• Chisimba is a very flexible and adaptable system, and its URLs don't always follow a repeatable pattern (or so we have believed).

Dynamic URLs are the kind that look like

http://localhost/ch/index.php?module=blog
&action=viewsingle&postid=gen18Srv59Nme5_2225_1316529949
&userid=1563080430.

With the Chisimba Short URL module installed, this could be

http://localhost/ch/daedalusphotos/

which is a static URL. A static URL could still represent all of the information in the original URL using a different technique, for example:

http://localhost/ch/blog/viewsingle/postid-gen18Srv59Nme5_2225_1316529949-userid-1563080430.html

which is still a mouthfull, but is a static URL.

Static URLs are generally assumed to be better than Dynamic URLs because:

• static URLs rank better in some search engines;
• search engines index the content of dynamic pages more slowly than they do for static pages;
• Static URLs are more friendlier looking to users of a system or site.

However, it needs to be born in mind that static URLs add overhead to the server, and require mod_rewrite to be turned on in Apache. Also, this only works on a Linux server as far as I know. I am not entirely convinced that the gains of using them outweigh these penalties, but in the world of business perception is reality, so as Kenga takes Chisimba to market, we will need to have static URLs in our toolkit. So here I am looking at how we could implement this in Chisimba.

There are two different things that have to be accomplished in Chisimba to make static URLS:

• the creation of the static links within the system;
• the parsing of the static links to build the dynamic content.

Lets take the first one first. Chisimba URLs are generated by a method in the object class, called uri(). A disciplined developer who adheres to Chisimba coding standards will build a link by calling this method, and passing it an array of key => value pairs, as well as the module to be called. For example the link

http://localhost/ch/index.php?module=blog
&action=viewsingle&postid=gen18Srv59Nme5_2225_1316529949
&userid=1563080430

used above will be created using the uri() method as follows:

$linkUri = $this->uri(
  array('action' => 'viewsingle',
        'postid' => 'gen18Srv59Nme5_2225_1316529949'
        'userid' => '1563080430'), 'blog');

This means that the uri() method could be used to construct the link differently based on a system parameter. For example, USE_STATIC_URLS could be set to TRUE or FALSE, FALSE by default. This would allow the uri() method to have additional code added to create either dynamic or static URLs.

The manner in which these static URLs are accomplished is going to be difficult in Chisimba because of the fact that it is not a single type of application. For example, we could use a concatenated title string for the blog, if all we were was a blog, but we cannot do that because any module can be the main module in Chisimba, and it is a multipurpose system. Here I suggest starting with pseudo directories, based on something that all modules will have, which is modulecode and action. Therefore we could have

http://localhost/ch/$modulecode/$action/

such that

http://localhost/ch/slate/view/

would open

http://localhost/ch/index.php?module=slate&action=view

The rest of the URL could then be constructed as

$param-$value~$param2-$value2~$param3-$value3.html

such that

postid=gen18Srv59Nme5_2225_1316529949&userid=1563080430

becomes

postid-gen18Srv59Nme5_2225_1316529949~userid=1563080430

There are other approaches that could work, including the one provided by http://www.webconfs.com/url-rewriting-tool.php as discussed further below.

The second thing that has to be accomplished is the parsing of the static URLs to access the dynamic content page. This requires Apache server with mod_rewrite turned on, and a .htaccess file to hold the rules for parsing the static URLs.

The difficulty with a complex application is to ensure that there is no duplication between static and dynamic URLs as this will result in a search engine penalty. Therefore, all public links in a given Chisimba installtion will have to point to the static URLs to avoid these penalties due to having duplicate URLs. We could generate a robots.txt file, and add all dynamic URLs to keep the search engines from spidering the duplicate URLs.

The URL rewriting tool at http://www.webconfs.com/url-rewriting-tool.php
takes the URL

http://localhost/ch/index.php?module=blog&action=viewsingle&postid=gen18Srv59Nme5_2225_1316529949&userid=1563080430

and provides two options

OPTION 1:  Generated URL

http://localhost/ch/index-module-(Any Value)-action-(Any Value)-postid-(Any Value)-userid-(Any Value).htm

eg. http://localhost/ch/index-module-blog-action-viewsingle-postid-gen18Srv59Nme5_2225_1316529949-userid-1563080430.htm

Create a .htaccess file with the code below
The .htaccess file needs to be placed in localhost/ch

Options +FollowSymLinks
RewriteEngine on
RewriteRule index-module-(.*)-action-(.*)-postid-(.*)-userid-(.*).htm$ index.php?module=$1&action=$2&postid=$3&userid=$4

OPTION 2:

Generated URL
http://localhost/ch/index/module/(Any Value)/action/(Any Value)/postid/(Any Value)/userid/(Any Value)/
eg. http://localhost/ch/index/module/blog/action/viewsingle/postid/gen18Srv59Nme5_2225_1316529949/userid/1563080430/

Create a .htaccess file with the code below
The .htaccess file needs to be placed in localhost/ch

Options +FollowSymLinks
RewriteEngine on
RewriteRule index/module/(.*)/action/(.*)/postid/(.*)/userid/(.*)/ index.php?module=$1&action=$2&postid=$3&userid=$4
RewriteRule index/module/(.*)/action/(.*)/postid/(.*)/userid/(.*) index.php?module=$1&action=$2&postid=$3&userid=$4

Neither of these approaches will be ideal for Chisimba, but the principle is clear.

This would lead to an automated approach. We could also have module specific static URLs, but the danger of having both is that links to them will result in duplicate URLs, and search engine penalties.

I would appreciate some feedback on this, as it is something that we must implement as we take Chisimba out into the commercial world.

Further reading

http://www.webconfs.com/dynamic-urls-vs-static-urls-article-3.php
 

My presentation from Mobile Marketing Africa, Hilton Hotel, Sandton, Johannesburg 2012 02 09

Mobile technologies are pervasive in todays world, and as the technology evolves and becomes more powerful, we are approaching the notion of ubiquitous computing. Yet at the same time, there is a large legacy of mobile phones that are not very sophisticated. A business that has not yet taken full advantage of mobile platforms has many opportunities open to it. Careful planning, rather than jumping in blind, is recommended, and examining one’s business ecosystem can provide a means to leverage mobile technologies to open new business opportunities.

This howto is written for cloud servers, which are virtualised machines sitting in a remote data centre somewhere. It has been tested with Digital Ocean and Rackspace. It should also pretty much work the same way for a Chisimba install on a local server in your own data centre.

Provision an Ubuntu server, either 11.04 or 11.10 depending on what your cloud provider has available. For a minimal install for testing, a 256Mb server will do. Record the password for root, and ssh into the server in a terminal. Ideally, you will want to allocate a domain name to your ipaddress and wait until the name propagates before you complete the final install of Chisimba.

$ ssh root@ip1.ip2.ip3.ip4
(where ip1.ip2.ip3.ip4 the ip address of your server. You may also ssh in to the domain name.)

Edit /etc/apt/sources.list and remove the comments from the Partner and Extras repositories in source.list and save it

$ vi /etc/apt/sources.list
$ apt get update
$ apt get upgrade

Then install the necessary software and configure PEAR.

apt-get install subversion apache2 mysql-server mysql-client php5 php5-mysql php5-imap php5-gd php5-curl php-pear php5-imagick php5-imap php5-ldap php5-mapscript php5-mcrypt php5-memcache php5-mysql php5-pgsql php5-pspell php5-snmp php5-sqlite php5-sqlrelay php5-tidy php5-uuid php5-xmlrpc php5-xsl

Update and configure PEAR.

$ pear channel-update pear.php.net
$ pear upgrade pear
$ pear upgrade-all
$ pear install --alldeps -f Config Log
$ pear install MDB2-2.5.0b2.tgz
$ pear install MDB2_Driver_mysql-1.5.0b2
$ pear install MDB2_Driver_mysqli-1.5.0b2
$ pear install MDB2_Schema-0.8.5
$ chown -R www-data:www-data /var/www

Next create a directory for Chisimba. It can be anywhere, but I prefer to keep it in /var.

$ cd /var
$ mkdir chisimba
$ cd chisimba

Check out Chisimba from Subversion. Please note that a more up-to-date release will be available shortly, and you should rather wget it, but for now do the subversion checkout. The framework is stable, and not under active development.

svn co https://cvs2.uwc.ac.za/chisimba/framework/trunk/ framework

If you want modules and skins (both of which includes a lot of junk) you can do

$ svn co https://cvs2.uwc.ac.za/chisimba/framework/trunk/ framework && svn co https://cvs2.uwc.ac.za/chisimba/modules/trunk/ modules && svn co https://cvs2.uwc.ac.za/chisimba/skins/trunk/ skins

You can either install modules directly from Module catalogue, by doing a live install once you have the base system up and running, or you can check out modules from subversion. This is recommended for production sites, and in that case you do not need to check out modules, only the framework core.

If you are only going to have one site, then you can put it in /var/www  - the default root on Ubuntu. If you are going to be doing virtual hosting of multiple sites, you can rather create a directory in /var called sites. Virtual hosting will be the subject of another post. here I assume you are only having one site, so we are working in /var/www and this will be opened as http://yoursite.com/

Now, you are going to use that most beautiful feature of Linux, symlinks, to link your site into the code.

$ cd /var/www
$ ln -s /var/chisimba/framework/app/index.php .
$ ln -s /var/chisimba/framework/app/gateway.php .
$ ln -s /var/chisimba/framework/app/classes/ .
$ ln -s /var/chisimba/framework/app/core_modules/ .
$ ln -s /var/chisimba/framework/app/cron/ .
$ ln -s /var/chisimba/framework/app/installer/ .
$ ln -s /var/chisimba/framework/app/lib/ .
$ ln -s /var/chisimba/modules/ packages
 

Create a directory for the skins and link it in
$ mkdir skins
$ cd skins
$ ln -s /var/chisimba/framework/app/skins/* .
$ cd ..

Create a directory for user_images and link it in
$ mkdir user_images
$ cd user_images/
$ ln -s /var/chisimba/framework/app/user_images/* .
$ cd ..

Now you can open your site in a web browser either as http://localhost (this is NOT recommended, as it will break your content links once you have  a fully qualified domain name) or http://yoursite.com (this is recommended, and it is best to wait until your domain name has propagated before doing the final install).

NOTE: Kenga Solutions will install Chisimba for you on an Ubuntu Server, or set up an Ubuntu server for you in RackSpace or Digital Ocean cloud. The installation and confirmation fee is R500. Until the interface is built, you can contact me for this service.

NOTE: You can use Facebook to obtain further information or comment on this blog post. Simply click the the post title if you do not see the facebook comments, and use the facebook comment form that appears at the bottom of the post.

Following on from the idea of dynamic canvases, we made it possible for Chisimba to render an entire template based on functionality of Chisimba that we call blocks. There are two types of blocks in Chisimba, narrow blocks and wide blocks. Narrow blocks work on the side columns of 2 and 3 column layout, and wide blocks work on the middle area of 1, 2 and 3 column layout. Of course, this is a rule of thumb, there is nothing to stop a developer from lacing two narrow blocks side by side in a wide column or in a single column layout.

To use blocks to make a template, it may be necessary to use output buffering. To do this, add the following to the top of the template:

<?php
ob_start();
?>

Then add the following to the bottom of the template:

<?php
// Get the contents for the layout template
$pageContent = ob_get_contents();
ob_end_clean();
$this->setVar('pageContent', $pageContent);
?>

You then need a layout template in your module that contains:

<?php
$objBlocks = $this->getObject('blockfilter', 'dynamiccanvas');
$pageContent = $this->getVar('pageContent');
$pageContent = $objBlocks->parse($pageContent);
echo $pageContent;
?>

In your controller, for methods that will render the block-based dynamic canvas, you need to ensure that you enable the layout template using:

$this->setLayoutTemplate('demo_layout.php');

For this to work, you need a version 3.0+ skin, and you need to use the Chisimba Canvas layout, which is as follows:

<div id="Canvas_Content_Body_Region1"></div>
<div id="Canvas_Content_Body_Region3"></div>
<div id="Canvas_Content_Body_Region2"></div>

Note that Canvas_Content_Body_Region2 is the middle, but needs to be presented last in order for the columns to float and align correctly.

For 2-column layouts this would be:

<div id="Canvas_Content_Body_Region1"></div>
<div id="Canvas_Content_Body_Region2"></div>

Blocks are inserted using JSON syntax as follows:

 {
    "display" : "block",
    "module" : "modulename",
    "block" : "blockname",
    "blocktype" : "blocktype",
    "titleLength" : "titlelength",
    "wrapStr" : 0|1,
    "showToggle" : 0|1,
    "hidden" : "value,
    "showTitle" : 0|1,
    "cssClass" : "cssClass",
    "cssId " : "cssId"
 }

Thus, adding the above block to the left column in such a template would consist of including it in the Canvas_Content_Body_Region1 div as follows:

<div id="Canvas_Content_Body_Region1">

 {
    "display" : "block",
    "module" : "modulename",
    "block" : "blockname",
    "blocktype" : "blocktype",
    "titleLength" : "titlelength",
    "wrapStr" : 0|1,
    "showToggle" : 0|1,
    "hidden" : "value,
    "showTitle" : 0|1,
    "cssClass" : "cssClass",
    "cssId " : "cssId"
 }

</div>

Everything except display, module and block are optional.

A template made up in this way might look like:

Note that the lines

$objFix = $this->getObject('cssfixlength', 'htmlelements');
$objFix->fixThree();

are there to equalize the columns. 

For a working example of this, see the dynamiccanvas module.

This was originally posted for Software Freedom Day last year!

Click image for larger version.

Given the renewing interest in reviving the South African FOSS policy, and the likely resistance to doing so, it is worth bearing these differences in mind. This is particularly true given our desire to create more innovation and more opportunities for the SMME sector in our country.