This manual has been created to provide thorough documentation of the IofC Drupal Project
. Our project will, in hindsight, be understood primarily through this document. Please review the table of contents to find your way.
Edward Peters, John Freebury
This book is structured as follows:
This first section provides an introduction to this project
, and some background information on why IofC has begun working with Drupal. It briefly surveys the history of IofC web development, how we reached a crossroads in thinking about the future, and how we came to the decision to switch to Drupal.
To understand our project you need to understand a little about the sites which are currently part of the 'family' of IofC sites. At time of writing (October 2007) they consist of 15 or so 'public' websites and one 'private' site for IofC activists, which we call the Extranet. All these sites apart from the Extranet share a backend and run off the same two mysql databases. A unique ID 'webuser' identifies all content so that all content can be shared across all sites.
The public sites are grouped into:
You can see that these sites share branding features, in most cases, though some look quite different.
All major content can be placed onto any of the sites (news stories, etc).
Furthermore the contact data used for these sites (email forms, etc) is taken from one data set which is used for the IofC contact database, integrated into the user info for users of the Extranet.
Our proprietary system (although unfinished) works relatively well. So why have we decided to move into Drupal?
Read on.....!
For over five years the IofC web team has been trying to develop an integrated content management system to meet the varied web and internet needs of this global network.
The first iteration (achieved in 2003) was a standalone Extranet (member) website, and several public standalone sites.
The second iteration (achieved in 2005) was the integration of all the public websites into one database infrastructure – with major benefits in content sharing and in speed of new site development.
The third iteration (on which we were working since 2005) involved a migration to a new, more solid architecture to carry the weight of an integrated Extranet (with its more specialised functionality) as well as the public sites, all in one system.
In mid 2007, however, it became apparent that our little team was too small, and not skilled enough by itself, to complete the third iteration in the way we had envisaged. A major factor was the retirement of our brilliant programmer, Vitalie, who had done most of the programming for four years.
After initial dismay at this reality check, we came to see it not as a failure, but as an opportunity to embrace a new vision of how IofC’s web needs are to be met.
After some weeks of research we reached the preliminary recommendation that we should change our
approach completely. Having been attempting to build a proprietary
system, using our own dedicated personnel, we decided that the way forward involved engaging with an Open Source CMS project
and community. Advantages of this approach include:
Drupal was recommended to us as one of the best CMS projects available. Our initial look at it confirmed that it might have most of what we needed. But there were other CMS fameworks to consider....
August 30, 2007: by Edward Peters
I’ve spent much of the
past 2-3 weeks researching Drupal as a possible CMS for IofC. My research has
involved a lot of reading, and also the installation of Drupal, adding modules
and trying to build IofC functionality in Drupal. I agree with those who say
that Drupal has a steep learning curve; I hope it’s true what people also say -
that after a time, once one becomes familiar with Drupal, it becomes easy!
Drupal or Joomla?
If IofC is to go the
Open Source route, there seem to be only two possible options – Drupal or
Joomla. I have not installed and played around with Joomla to any extent. But I
have done some reading on it. The conclusion is that Joomla has some advantages,
and Drupal has other advantages. It all comes down to what is most important
for us – neither product will give us the best of all worlds. A not very recent
comparison can be found at http://www.alledia.com/blog/general-cms-issues/joomla-and-drupal-%11-which-one-is-right-for-you?/.
This was written before the launch of Drupal 5 (now stable) and Joomla 1.5 (not
yet stable, but likely to be a big step forward).
An independent
assessment done for the Canadian Union of Public Employees (CUPE) is available
at http://openconcept.ca/sites/openconcept.ca/files/OpenConcept%20-%20CUPE%20CMS_0.pdf;
it makes a clear recommendation in favour of Drupal, because of Drupal’s better
multisite and multilingual functionality.
Joomla is more
commercially oriented, and has more of a commercial development community.
Drupal is more fully open source, and it can be harder to find commercial
developers for it.
What I have read indicates that Drupal is better in ‘architecture’ and Joomla better in most ‘functionality’. One developer writes: “As a developer with the capability to write code, I find myself much more concerned with architectural matters. Functionality can be programmed, but I’m at the mercy of architecture. Put another way, give me the right tools and materials, and I can build anything.”
My view based on what I have so far discovered is that Drupal is a
better option for us than Joomla.
Internationalisation
This is a core
requirement for IofC. In Drupal release 5 there is no core support for
multilingual content (this can be achieved by adding the i18n module, but it is
limited). In Drupal 6 much of the i18n functionality is built into the core,
and it is being seen as a big advance. See http://www.developmentseed.org/blog/internationalization/comparison_chart
for
I have experimented
with multilingual content, and it works quite well, including the translation
flow. However, I ran into a problem with Views (the module that creates dynamic
lists of content) and could not get it to work well with multilingual content. I
could save views as blocks and then add them to pages, but the Page View mode
did not work properly. I think there may be some compatibility issues between
the i18n and Views modules. The Views module is being completely rewritten for
Drupal 6, so we may find big improvements
- and at the very least no compatibility problems.
Multisites
This is another core
requirement for IofC. We have yet to be satisfied that this can be achieved
properly. But all I have read about Drupal makes me fairly confident that it
can be done. The assessment done for CUPE (referred to above) specifically
mentions Drupal’s multisite capability as a core strength for an organisation
like CUPE which needs hundreds of small local websites for its members.
There are likely to be
more than one way of achieving this, and we will need technical advice on the
best way. We have to be sure we can achieve multisite functionality, before we
go too much further.
Taxonomy
This system of being
able to classify and categories almost all types of data is very powerful and
gives us great scope for major functionality.
Themes
These are powerful, but
take some work to understand. In a multisite environment, page templates are
stored by site. I think we will be able to customise look and feel as we have
done in our interim system, though it will work differently. Some aspects may
be more powerful than in our system (e.g. you can have templates for different
nodes and for different users), while other aspects may be less powerful than
ours.
Contacts, virtual databases, users, groups and
security
From my limited
exploration of CiviCRM, I think that it will handle most of our needs, but I
have not gone deeply into this.
Many things are simple in Drupal
As I have gone along I have been impressed by how much Drupal can do without any programming. Some of it is big and some of it is just little but valuable things. A few brief examples (there are many more):
But we will have to make sacrifices if we use
Drupal
There is no getting
away from the fact that we will not get very close to our ideal CMS
functionality if we use Drupal. With our proprietary system we can achieve just
about anything we want, but with Drupal we will have to sacrifice some of our
ideas. In particular I think we will have to modify our hopes with regard to:
Weighing it all up
For most of the past
three weeks I have been leaning heavily towards Drupal. But, as I have become
more aware of the limitations it will place on us, I have remained open to the
idea of continuing our proprietary system. To go that route would see us with a
product which would undoubtedly be closer to our ideal in many areas. But it
too would involve considerable compromises as we could not expect to develop
all the interactive Web 2.0 features we want, nor keep up with the new
developments that are unfolding all the time in the world of the web.
Going with Drupal will
mean sacrificing some of our ideas, but it will mean embracing many good new
ones. It will give us significant advantages in terms of adherence to
standards, access to core functionality which is time-consuming to programme,
participation in a worldwide community of developers, and the capacity to stay
close to the leading edge of web development.
My recommendation
It is clear to me that
Drupal is not going to meet all our needs. But rather than focusing on what we
will lack, I think we should focus on what we will gain. Let’s embrace Drupal
and create an IofC framework and online community which utilises its strengths.
APPENDIX: Websites using Drupal
A full inventory of
Drupal powered sites is at http://drupalsites.net/.
The following sites are among those which use Drupal and can give us some
confidence that we can achieve what we need:
http://www.greenpeace.org.uk/
http://www.theonion.com/content/
Amnesty International is apparently rebuilding its sites and CMS using Drupal.
This section contains documentation relating to the research and planning phase of our project
. It includes some general documentation giving guidelines on HOW to write requirements and use cases most efficiently.
Every requirement should be a single active sentence, as short as possible, but no shorter. Long rambling sentences quickly lead to confusion and error, not to mention boredom for the reader.
Bad:
The user must login to the
system by entering a password and a username which will be verified by
the system against the usernames and password that they have stored in
the user information repository in order to ensure that the user is a
valid user who has the right to user the solution.
Good:
The user will login by way of entering a valid username and password combination.
Requirements must be atomic in order to ensure that compliance with the requirement is measured by the single goal of the requirement being achieved. If you can think of a small number of related tests to verify a requirement’s implementation, it’s probably written at the right level of detail. If you envision many different kinds of tests, perhaps several requirements have been lumped together and should be separated.
Bad:
The user will be able to create, edit, delete, suspend, open, and replace all files which they have the necessary access to.
Good:
The user will be able to create a new file, as long as they have the Add File user right.
This is one of the most subtle and difficult issues in writing requirements due to its subjective nature. In order to achieve this goal the requirement must be clear and explicit, but care must be taken not to take this too far as the text can become unreadable and boring and this will defeat the core objective of requirements – in other words they are meant to be read by others.
Bad:
In order to delete a task the user must enter some details.
Good:
In order to be able to delete a task the user must enter a further password which grants them the rights to delete a task.
Many words used informally to indicate desired qualities are too vague for use in requirements. Vague terms include “user-friendly”, “versatile”, “flexible”, “Configurable”, “Approximately”, “as possible”, “efficient”, “high performance”, “quickly”, “modern”, “well designed”.
Bad:
The searching functions must be as efficient as possible.
Good:
The searching functions must return their results in no more than 10 seconds regardless of the size of the results.
A good Requirement is at a high enough level to be understandable and precise enough to be complete.
Bad:
The solution will have security.
Good:
In
order to protect the data the system shall be subject to security by
way of all users being required to enter a valid username and password
combination in order to perform any function.
Care must be taken that requirements do not contradict themselves in their descriptions, nor contradict other requirements
Bad:
The system will be a 24x7 solution although it will normally be unavailable on weekends.
Good:
The system will be available 5 days per week through out the year.
There is no use in specifying requirements which are technically impossible or beyond the law as they will never be implemented.
Bad:
The system will read the mind of the user and determine which colour is their favourite.
Good:
The
system will establish the favourite colour of the user by asking them
pre-defined questions, in order to establish their favourite colour by
process of elimination.
A good requirement should be a business necessity and not a wishful thought by an individual.
Bad:
It
would be good for the solution to enable a user to add more than one
property to an application, although only one property can be linked to
an application.
Good:
A user can add only one property to an application.
Every requirement should specify clearly a single desired and achievable result.
Bad:
The printout will contain some text, although it is uncertain what this text will contain.
Good:
The printout will contain a list of users and their address details.
Every requirement must be verifiable. Often it is possible to indicate the method of verification by adding a simple phrase to qualify a basic need. This enables the requirements to be a good base for the acceptance criteria of the solution to be delivered.
Bad:
The solution must be designed
in order to guarantee that all of “very famos company” staff will enjoy
the experience of using the application.
Good:
The solution must be designed in accordance with the user interface guidelines specified by standards.
Requirements specify the design envelope, and if too much detail is supplied the design of the system will begin prematurely. Sometimes this is unavoidable if a requirement is to design the solution in a certain way, which in effect locks the designers in to designing the system according to the requirement stating the design constraint. Specifying the design rather than the actual need often increases the cost of systems by placing needless constraints on design and development.
Bad:
The user entity will be made up
of three tables. The user table will be joined to the role table via
the user_role table allowing for a user to have multiple roles.
Good:
The data model will enable a user to have one or more roles.
To see if a requirement statement is sufficiently well-defined, read it from the developer’s perspective. Mentally add the phrase, “call me when you’re done” to the end of the requirement and see if that makes you nervous. In other words, would you need additional clarification from the System Requirements Specifications author to understand the requirement well enough to design and implement it? If so, elaborate on that requirement before you proceed.
Requirements which contain let-out clauses significantly increase the risk of the requirement not being fully realised. They look as though they are asking for something definite but at the last moment they back down and allow for other options. Problems arise when the requirements are to be tested and someone has to decide what, if anything could prove the requirement was not met. Dangerous let-out word include “if”, “when”, “except”, “unless”, “although”.
Bad:
The login process will never take no longer than 3 seconds unless the system is busy.
Good:
The login process must not take longer than 5 seconds to complete at all times.
Engineering is a real-world activity. No system or components is perfect. Wishful thinking means asking for the impossible. Developers will rightly query or reject wishful requirements. Wishful terms include “100% reliable”, “Hand all unexpected failures”, “Satisfy all users needs”, “Run on all platforms”, “Never fail”, “Perfect”, “Upgradeable to all future situations”, “future proof”.
Bad:
All web browsers will be supported including any future browsers without the necessity to change any of the code.
Good:
Internet Explorer 5 and above, Firefox 2 and above will be supported only on a Microsoft Windows operating system.
Plans are essential, but they do not belong in the requirements of a solution. Usually they are updated throughout the project life-cycle, where as the requirements should stabilize. Mixing requirements with plans tends to increase the requirements workload through extra revision and review meetings. Danger signs are references to dates, deadlines, project phases and development activities.
Bad:
The solution will begin as a desktop application but will be converted into a web application at some time in the near future.
Good:
The solution should be written so that a web version can utilise the core code without the necessity to re-write the core code.
Requirements are part of a contract between customer and developer, with users as interested third parties. There is no room for “wish lists” – general terms about things that somebody probably wants. Danger signs include use of generalisation words such as “usually”, “generally”, “often”, “normally”, “Typically”.
Bad:
The solution will most likely be deployed on five servers.
Good:
The solution will be deployed on five servers.
Possibilities are indicated with terms such as “may”, “might”, “ought”, “could”, “perhaps”, “probably”. If developers do what they have to, they will always ignore things that user might possibly require.
Bad:
At some point in the future the solution may need to be able to run on UNIX servers.
Good:
The solution must be able to run on servers with both Microsoft Windows and UNIX operating systems installed.
The word “Or” can often cloud or severely confuse a requirement and render it as un-verifiable due to the conditional nature of the requirement. Where “Or” is used, often this indicates that there are two requirements being joined into one.
Bad:
The user can download customer documents to their local machine or they can print the files.
Good:
The user can download customer documents to their local machine
While including the same requirement in multiple places may make the document easier to read, it also makes it more difficult to maintain. This results in the necessity to update multiple instances of the requirement at the same time to avoid inconsistency.
Where possible avoid jargon, abbreviations and colloquialisms. Where jargon or abbreviations are used, they must be listed with their meanings in the project glossary.
Bad:
If a user enters their SAD, they will in effect be considered as top dogs of the system.
Good:
If
a user enters their special authentication details, they will be
considered as super users, which entitle the users to perform all
functions.
The scope this section is to present all functional requirements for “IofC Drupal Project”.
Requirements defenition All requirements are grouped into the following top level packages:
Functional Requirements Functional requirements depict the operations that the IofC desires the solution to be able to perform.This is the most important type of requirements as it answers the question “What does the solution have to do?”
Non-Functional Requirements Non-functional requirement are mostly constraints which we have to work with in order to make the solution do, what the functional requirement state it must do.
Packages
Each top level package will have a two letter prefix which identifies the type of requirements which will be within the package or within sub-packages under the package. The high level outline of structure is illustrated below:
Requiremens
A package represents a group of requirements that have a common theme or are linked to the same area in the solution. All requirements packages under the top level packages and requirements will have a unique prefix which is constructed in the following manner: "AAnn_nn - Package Name/Requirement Short Description" AA refers to the two letter prefix identifying the type of requirement, and nn being a numeric which will be unique under each top level package (i.e. Requirement Type). The underscores (_) represent how many levels under the top level packages the requirement/sub-package resides.
The purpose of this guideline is to elucidate the best practices to be followed when the requirements gather on a project are documented. This guideline does not have the objective of being prescriptive; it is more a source of guidance describing how to produce requirements to a high quality.
Many people often view functional requirements analysis (often
requirements analysis generally as a process that does not add much
value to a project (particularly clients). They feel they know exactly
what the solution must do, and assume that they know what it should do
exactly and are able to communicate this to solution developers. The
reality is that this is simply not true, but because of this
misconception, when requirements analysis is carried out not enough
time is allotted to the task.
Functional requirements are the hardest of all forms of requirements to
tie down as they are so intrinsically linked with humanistic needs.
Therefore functional requirements take up most of a systems analyst’s
time on a project. In the real world there is only a finite time
allotted to requirement analysis, and often they are submitted before
the analysts consider them to be a complete picture due to project or
commercial reasons which are valid.
If an analyst has to submit their analysis work before they consider it
to be complete, this fact must be communicated and the areas which lack
completion highlighted and recognised as a risk. It should be noted
however that an hour extra spent on driving a requirement down to fine
detail can save a designer days or weeks, a developer weeks and project managers
a lot of explaining to do.
When ascertaining and documenting Requirements they will be grouped into the following top level packages:
1.Functional Requirements
Functional requirements depict the functions that the client expects to be able to perform within the solution.
2.Non-Functional Requirements
Non-functional requirements can be broken down in to the following 2nd level packages:
Functional requirements depict the operations that the client desires the solution to be able to perform. This is the most important type of requirements which a System Analyst can capture on any project as it answers the question “What does the solution have to do?” Non-functional requirement are mostly constraints which we have to work with in order to make the solution do, what the functional requirement state it must do.
Often clients have a broad idea of what they want but are not very good at describing this to a level of detail which we can consider to be a functional requirement. Sometimes gaining functional requirements from a client is like obtaining blood from a stone (although it is much simpler in reality!), as they either lack time, detailed knowledge and understanding of what they want, or they are bad at communicating. Whatever the reason, it is up to the System Analyst to circumvent these issues and draw the blood from the stone.
The most common situation which a System Analysts is in is where a client uses a high-level broad description of what they want a solution to do. An example of such a situation is where a client stipulates that they want a web shop where they can display and sell their products online. Often a client will believe that this is sufficient in order to get on a performed the development, when it is clearly not the case. Without thinking very much this requirement could be take us up very different paths, many of which are not what the client really wants, although they satisfy the basic requirement as stated by the client.
In order to establish the requirement, it is often useful describing the processes which are involved with the solution as a check that their requirements are understood by both the System Analyst and the client themselves.
Walking through the above example, the analyst could describe the process from a user of the web shop point of view. Soon questions will erupt either from the client or the analyst where it could be established that the client would like the user to be able to order the item online via a credit card system, and then record the orders to be used for when the user logs on next.
This would involve a user having to register their details when making purchases. This would also involve the data being stored securely as credit card information will be stored.
There was no mention of credit cards, registering etc… initially however these important requirements were flushed out through stepping through the high-level requirement.
When faced with such requirements which lack definitive clarity walking through the process with the client most often flushes out many other requirements (more detailed) which the client had either not mentioned or not thought off.
One common aspect which many clients (and Analysts) forget is that for every item of data held in the solution, the client will normally want to be able to modify/administer it. This area is often trivialised, without just cause, as often this area is more complex and takes longer to develop than the presentation of the data. Each time an Analyst sees data elements in the requirements, and does not see any means to administer it mentioned, alarm bells should be sounding loudly.
The most important word when gathering functional requirements is the three lettered word “Why”. Often requirements are expressed without their being a “real” need or because the client has rushed to a solution without thinking of alternatives.
An example of its importance can be illustrated in the following example:
A user states that “a coffee pot must be made of stainless steel”. An analyst could ask “Why?” they need that particular material, and they may say “because a glass pot may break”. If the analyst then asked “Why should it break?” the user may answer “because the pot is often left on the heat oven even when empty”.
If the analyst asked why this happens they may be told “because the pot is shared by many people who just pass through, and the heater does not switch off when the pot is empty”. So as we can now ascertain the correct requirement is that the coffeepot heater should switch off when the pot is empty. However this is a million miles away from the initial requirement the customer stated.
Most of us find it hard to visualise a proposed solution or a process without the use of a diagram or ten. Clients also suffer from the same problem. Therefore the analyst should utilise diagrams as and when necessary in order to clarify the requirement in their mind as well as check that the client is clear in their minds too!
When a client request the solution to perform a certain function the analyst should always think: Can it be done? The analyst need not be a developer or designer to understand that what the client desires, just cannot be done, be it for technical or logical reasons.
If this is brought to the client’s attention in the requirement phase of a project, it is far easier to get a compromise from a customer, than if the customer is told half way through development that their requirement cannot be done.
Granted there will be some requirements which will be established to be impossible during development, but these can be minimised by an analyst thinking about whether it can be done or not. If possible an analyst should be thinking “how would I do it, if I had to and had the necessary skills and time?” If the analyst can answer this question, more often than not the requirement can be achieved.
The purpose of the following section is to provide a list of questions which a Systems Analyst can select a subset from, in order to be able to stipulate as detailed as possible non-functional requirements.
Functional requirements are largely project dependent in terms of their subject matter, whilst non-functional requirements are fairly consistent across projects regardless their subject matter although the details/values will differ from project to project.
The lists in this section do not purport to be exhaustive and nor do they purport to be a list of mandatory questions. They are more a guidance as to the type of questions that a System Analyst should be asking in order to establish the non-functional requirements of a project.
A business requirement can simply be described as the business reason why the analyst is working on the project to produce the solution for the client.
Clients do not employ analysts, developers, designers and project manager’s to produce software solutions which do not have a business need, as the software development world is an expensive one to play in without no cause.
Establishing the business drivers behind a project can assist the analysts in helping the client define the solution they actually need, rather that what they think they need.
Analysts do no necessarily have the business expertise in the domain which the client practices in, and asking business associated questions both establishes the business drivers behind the project and the analyst can gain some insightful business domain knowledge which will assist the analysts in understanding the project better themselves.
Below and overleaf are some typical questions which the analyst should ask a client in order to ascertain the business requirements of a project:
• Why does the project exist?
• What is the business reason of the project?
• What are the key business drivers to determine the success of the project (i.e. increased productivity, reduction in costs, increase in sales etc…)?
• Is the solution backed more by technological decisions rather than business decisions? Is it a process driven change?
• Do they facilitate business change, which will inevitably happen?
• What is the expected life of the solution?
• When is the solution expected to have paid for itself?
• Is the purpose of the solution measurable in terms of ascertaining the success of the solution? If not how does the customer plan to evaluate the success of the solution?
• Has the user performed a GAP analysis in order to establish the requirements of the solution?
• Does the current business processes fit well with the technical processes part of the new solution?
• Is the new solution replacing an old one? If so why? Did the old one fail in its objectives? Has it been made obsolete?
• How does the project fits into wider business plans and programmes
• Who are the key stakeholders?
• Who from the customer will be providing most of the requirements, needs and feedback?
• Who are the proposed key users of the solution?
• Are any existing members of staff going to be replaced as a result of the solution being adopted (source of political tension…)?
• Will there be process changes at the same time as the adoption of the new solution?
• Are there any major business activities such as mergers, takeovers, floating etc… coinciding with the solution development/deployment?
• Are there any major business activities such as mergers, takeovers, floating etc… which will have an effect on timescales of delivery?
• If the user has existing data from the current systems, will this need to be migrated into the new solution? If so who will be responsible for this task?
• Will the client be first do market? Is that their aim?
• Who are their competitors?
• What differentiates the client from the competitors?
The user interface is the human door to a solution. The average user does not want to see the nuts and bolts which securely hold the solution together, they want to work with the solution, and this is does normally via a graphical user interface (although not always graphical). Ascertaining the user interface requirements of a client for their solution is very important as that is how most people are going to judge the success or failure of the solution.
Below and overleaf are some typical questions which the analyst should ask a client in order to ascertain the user interface requirements of a project:
• Does the user require only a command line type interface?
• Does the user require both a command line type interface as well as a graphical interface?
• Does the user require a web-based user interface or an desktop application based user interface?
• Will we or the customer be developing the customer’s UI?
• Will the customer require prototypes? If so what prototype strategy will be employed (i.e. throw away, embryonic…)?
• If prototypes are to be produced what is their Scope (i.e. Subset of functions, all of them…)?
• If prototypes are to be produced who will be the target audience?
• If prototypes are to be produced will it be a signed off deliverable?
• Is the customer image conscious?
• Does the customer possess user interface guidelines, if not should we follow Compudava user interface standards or other user interface standard?
• What are the colour schemes which can be used within the solution’s user interface?
• Does that customer have any branding they wish to have employed in the solution? If so does the customer posses examples?
• Are we updating an existing produce where the branding will be constrained by the legacy application? Or will the user interface be based on a new vision?
• What kind of coverage of the disabilities act is expected? (i.e. AA, AAA rating….)
• What are the customer’s data input methods? (i.e. Mouse, keyboard, bar code scanner etc…)
• Are there any technical accessibility constraints? (i.e. no client side scripting, flash…)
• Which resolution must the solution support?
• Does the customer have any preferences relating to the existence of horizontal and vertical scrolling bars?
• Are there any particular data controls which the data prefers or dislikes?
• What type of user will use the application in terms of technical and subject matter knowledge? Who is the audience? What is the assumed level of understanding of the users?
• What is the percentage between pages for internal users and those for external users?
• What languages and currencies must be supported?
• What type of outputs other that on-screen is required (i.e. reporting, exporting etc…)?
• Must the application be compatible with different operating systems? This may affect the language used in order to create the user interface.
All software solutions require hardware on which to run on, it cannot work without it. It makes sense therefore to find out exactly what the solution is planned to be running on.
These details often guide in a major way many of the design decisions that are made once the requirements and use cases are passed to the design team. In order to allow the designers to design the most suitable solution, as many details pertaining to the hardware requirements should be ascertained by the analyst.
Below and overleaf are some typical questions which the analyst should ask a client in order to ascertain the hardware requirements of a project:
• Either the client will have to specify the hardware on which the solution is going to be installed, or they ask us to specify the hardware which they require to meet performance objectives.
• Regardless who specifies the hardware, the following will have to be established:
a) Number of Servers
b) Number of processors
c) Processors
d) RAM
e) Type, number and size of hard drive(s)
f) Type of hard disk controller(s) (i.e. RAID, IDE, SCSI…)
g) L2 Cache
h) Number and type of network cards
• Bandwidth to be supported
a) Type of communication between Server and Client
b) Type of communication between Server and other servers in the solution (i.e. Database server and Web Server)
c) Type of communication between Server(s) and other customer systems the solution will interact with that already exist.
• What budget does the client have for purchasing hardware for the solution (if they divulge this information)?
• What is the typical upgrade cycle in terms of hardware for the client (i.e. All desktops every 2 years….)
• Where are the server(s) to be part of the solution or to be involved in the solution in any other way to reside? (i.e. Client site LAN, data centre, multiple client sites with WAN…)
• Does the client already have recovery plans for other servers which will apply to the servers used in the solution?
• Will the client require redundancy to achieve promised SLAs or guaranteed up-time?
• Will we utilise servers already purchased by the client for the solution?
• Has the customer planned to have a test environment prepared for UAT?
The solutions we develop often interact with one or more software elements on the client’s environment. Often these interactions constrain the way in which we can develop the solution or at least will guide the designers in design the best solution according to the scope of interaction with other software.
Below are some typical questions which the analyst should ask a client in order to ascertain the software requirements of a project:
• What software should the solution be compatible with?
a) Browser
b) Operating Systems
c) Third part software
• How portable should the solution be? (i.e. we develop for MySQL now but know that in future releases it will have to be ported to SQL Server)
a) Operating System
b) Database
c) Application Server
d) Programming language
• When developing the solution whose coding standard need to be followed?
a) Compudava coding standards
b) Customer coding standards
c) Other coding standards
• Who will support the solution post deployment?
a) Compudava will provide support
b) Customer will support the solution themselves
• Has the customer expressed any of the Third Party software which must be used by the solution?
a) Operating System
b) Database
c) Application Server
d) Programming language
• Has the customer assigned any of their budget towards the purchase of licences, which may constrain the software that can be utilised?
How many times have we heard that the solution must work as fast as it can? Is that a real requirement? It sounds like a vague requirement which is not really measurable. In order to prevent designers and developers dealing with such vague requirements, it is up to the analysts to ascertain what level of performance the client expects and what constraints must the designers and developers deal with.
Below and overleaf are some typical questions which the analyst should ask a client in order to ascertain the performance requirements of a project:
• How many named users is the customer expected to use the system?
• What will be the maximum number of concurrent users of the system?
• What will be the maximum number of concurrent users in peak times? What is the duration of these peaks, and how often can they appear?
• Establish a set of key scenarios which will be the typical usage of the system. The following details for each scenario should be ascertained:
a) What are the components of the scenario? (i.e. steps)
b) Number of users (as a percentage) which will perform each scenario daily.
c) The frequency each scenario is going to be employed per day
d) How much sleep time (i.e. user’s thinking time) is appropriate?
e) What is the acceptable and expected maximum response times for each scenario for each type of connection which is relevant (i.e. LAN, 512kb link, 28kb link…).
f) What is the acceptable and expected maximum client perception time for each scenario for each type of connection which is relevant (i.e. LAN, 512kb link, 28kb link…).
• Are there any functions which the solution will perform which can be identified early as being business critical and/or resource hungry? If so specify these as these will form the starting point for performance testing and tuning.
• What is the current and expected volume of data which will form part of the solution by object type?
• What is the expected growth per object as a percentage per month/year?
• What is the expected average size and number of external objects (other than code or data)? (i.e. Images, documents, files…)
• What is the expected availability of the solution? If the client states 24x7 ensure that the client really means 24 hours per day, 7 days per week, 52 weeks per year, 12 months per year etc….
• What level (i.e. errors, security, object creation, modification and deletion…)of auditing is required?
• Where will solution data be stored?
a) Flat/XML file
b) Relational database
c) XML database
d) Other
When a client mentions the words username and password when specifying requirements for the solution, the analyst should immediately think about security in a broader way. The questions below will assist the user in ascertaining detailed security requirements.
• What is the type of solution that is being created?
a) Intranet Web Application.
b) Intranet Desktop Application.
c) Internet application which provides public information.
d) Internet application which manipulate sensitive data (financial transactions, secret documents etc).
e) Other?
• What methods of authentication will be used?
a) Web Based authentication
b) HTTP Authentication:
a. Basic
b. NTLM
c. Digest
a) Other?
• Should system forbid simple passwords (i.e. master, john23, administrator) and allow only strong ones (i.e. @&#J83^zx#0(-+, WeN6%2@!]dEp>)?
• Should brute-force attacks be avoided and if so how? i.e. After 5 incorrect login attempts user was locked for 15 minutes.
• What events are to be logged?
a) Any exceptions are logged.
b) Any possible attacks are logged (Incorrect login attempts, authorization bypass attempts, data validation bypass attempts and other).
c) All user activities
• Should the user have the possibility to recover lost passwords themselves (System provides password reminder mechanism) or will it only be able to be reset by an administrator (sent to user by email, SMS etc…)
• How are sessions to be maintained if they are to be implemented?
a) Cookies
b) Session Tokens
c) Other?
• What are the session options?
a) Specify in seconds/minutes/hours timeout period
b) Should system allow multiplicity (i.e. Can the same login in the same time from different locations?)
c) What algorithm of session token generation should application use?
• How should the application handle bad data?
• Should there be Client side validation? i.e. JS Validation is made in browser to avoid additional flow of data.
• How sensitive is the data which the solution will store and access?
• Is there any credit card/other financial information which the solution uses and stores?
• Are there any legal requirements pertaining to the protection of any data which is being stored and accessed by the solution?
• What level of security is the client expecting?
• How important is security in comparison to performance?
Changes to requirements can occur at any time throughout the life cycle of a project. The two most frequent times for these changes are as follows:
If the requirement is changed before they are signed off, there is no issue relating to change control of the requirements, as they are not part of a baseline.Once the client has signed off the requirements, any changes are a change to a baseline and therefore must be tracked.
This is an early draft.
| Functional requirements for IofC Drupal project. Version 2.2 | |||||||
| Notes | Open issues (19) | Phase | Priority | Difficulty | Version | ||
| FR01 | Multiple Domains/Sites | This package relates to the functionality required for providing multiple websites within one integrated system. | 1 | 1 | |||
| FR01_01 | The solution must deliver an integrated system for running many domains/websites | initially 20-25, but growing. | 1 | High | High | 1 | |
| FR01_02 | Each domain/website must be able to define a look for its user interface using site specific theme using theme, menu and administration. | 1 | High | High | 1 | ||
| Each domain/website must be able to build its own content. | |||||||
| FR01_03 | Nodes, images and users/contact records must be shareable across all domains. | 1 | High | High | 1 | ||
| FR01_04 | Solution must use single Drupal's codebase for all websites | Having one codebase we can simplify process of installation of security patches and upgrades of Drupal core. | There are a lot of tricks how to achieve that. WE should choose one which suites the best for our needs. | 1 | High | High | 1 |
| FR01_05 | A User must be able to login from any site provided by solution . | Users are shared across all sites, so that any authenticated user has access to the ‘private’ part of any website, and is able to move seamlessly between these ‘private’ websites without being required to log in again. | How to share user's accounts ? Think about global Directory using OpenLDAP. www.openldap.org Dupal modules: ldapauth, ldapgroups, ldapdata. Seems to be promising for that. | 1 | High | High | 1 |
| FR01_06 | Each website (an international one, and 20-50 national and programme-oriented ones) needs to have both: A ‘public’ part (for anonymous users) and A ‘private’, community part (for authenticated users) | Notions “public” and “private” site-part are misleading here. It sounds like 2 separate places. Do you agree ? Each Drupal basic building block (node) must have access attribute, that will differentiate a node like public ( for anonymous users) or private ( for authenticated users) | |||||
| FR02 | Groups | This package relates to the group system to be implemented. | 1 | 1 | |||
| FR02_01 | Solution must provide dynamic “Group creation” functionality | The process of creating a Group must be easy and intuitive and minimise the need for intervention by sitewide administrators. 4 group roles should be created automatically for a group when that group is created: * Member – defines who is part of the Group * Administrator – can administer all parts of the Group's membership except editing of contact records. * Webmasters – administers pages and content for the Group, including for a public website belonging to the Group. * Data Controller – responsible for those contact records assigned to the Group's data controllership (if any). | One group may have a website, but another may not. If a group does not requires a dedicated website, then why does it require a Group-webmaster role in place ? | 1 | High | Unknown | 1 |
| FR02_02 | Solution must provide dynamic “Subgroup creation” functionality | A group must be able to contain another group, so that the members of the subgroup are also members of the containing group. | 1 | High | Unknown | 1 | |
| FR02_03 | Group creation operations must be tied to a role. | Any Advanced User may create a Group. | 1 | High | Unknown | 1 | |
| FR02_04 | Group administrator must be able to define additional group specific roles | Any group member may have as many roles as required. | 1 | High | Unknown | 1 | |
| FR02_05 | Group must be able to create ant type of Content | A site may have many groups associated with it -- when a user creates a new site at least one group must be specified -- that group's content (team homepage etc.) will automatically be linked to the new site. | 1 | High | Unknown | 1 | |
| FR02_06 | Each group must have its own calendar | Events will be shown in group-calendar. Group administrator can hide events from their group calendar. | 1 | High | Unknown | 1 | |
| FR02_07 | Access to some content on each private website must be able to be limited to a group. Groups need to be able to have their own Group pages/menus, etc within any domain/site. | ||||||
| FR02 | Internationalisation | This package specifies the multilingual functionality required. | 1 | 1 | |||
| Each website must be deliverable in two or more languages. | where needed | 1 | High | Unknown | 1 | ||
| Solution must provide a possibility to install additional languages. | English will be default language for the system. Other languages installed initially will be: French, German, Swedish, Norwegian, Finnish, Dutch, Spanish, Portuguese, Russian, Chinese, Japanese. | 1 | High | Unknown | 1 | ||
| There must be provision for RTL languages. | Drupal core provides RTL | 1 | Low | Unknown | 1 | ||
| On a multilingual website, the visitor must be able to choose from available languages. Chosen language must be used for user interface. | The user interface must be in the chosen language, where translated strings are available. Strings must be multilingual | 1 | High | Unknown | 1 | ||
| 1 | High | Unknown | 1 | ||||
| Content/nodes must allow a translation workflow. | 1 | Medium | Unknown | 1 | |||
| The translation workflow should have an automated notification systems for translators. | 1 | Low | Unknown | 1 | |||
| FR03 | Theming | This package describes issues related to the look and feel of the website. | 1 | 1 | |||
| FR030_01 | Themes for national and programme websites must be easily cloned and adapted from default template. | The default theme must be based on the current template at www.iofc.org | 1 | Low | Low | 1 | |
| FR030_02 | Solution must provide UI template support | Visually unrelated themes must also be available for some websites. | 1 | High | Low | 1 | |
| FR04 | Content | This package details the main types of content to be used. | 1 | 1 | |||
| FR04_01 | Support for following content types must be provided: Page, Article,(Story), Event, Blog, Book, Forum, Project and Project issues, Images, Feedback, Comments | A node must be editable only by its creator and by users of the group which 'owns' it. | 1 | High | High | 1 | |
| FR04_02 | Each content type may have its own required fields, in addition to the default set. | What is the purpose of that “required field” ? | 1 | Unknown | Unknown | 1 | |
| FR04_03 | Each content type must be configurable to allow revisions, comparison of revisions, and reversion.( Except Comments) | 1 | Low | Low | 1 | ||
| FR04_04 | Nodes must be shareable across domains and groups unless specified below. | Thus a node published on Site X would generate the following possible options: * It could be published by Webmaster X only on Private Site X and/or on Public Site X * It could be shared with the Network (all sites) but not actually published anywhere else by default * Webmaster Y could then decide to publish this node only on Private Site Y and/or on Public Site Y * Only the creator of the node (Webmaster X in this example) is allowed to edit/delete the node * Webmaster X needs to be able to publish the node only to Group Z (a group exclusive to Site X), in which case it would be visible only to members of Group Z on Private Site X and not anywhere else on Site X or in the Network. Webmasters of Sites Y and Z obviously need a method to view all nodes which have been ‘shared’ by other Sites, and decide whether to publish them to their site. The only amendment to the general rules above might be that a node published in Site X (but not restricted to a Group) might automatically also be published to Private Site A (the private/community section of the parent/hub/international site). | 1 | High | Very high | 1 | |
| FR04_05 | Vocabulary of types must be used for content classification. | 1 | High | Low | 1 | ||
| FR05 | Page | 1 | 1 | ||||
| FR05_01 | It must be possible to create Pages. | Pages may only be added and edited by Webmasters | 1 | Low | Low | 1 | |
| FR06 | Article (Story) | 1 | |||||