Software Development Services
We provide a general and comprehensive range of Software Development services. Our simpler projects tend to involve replacing manual or excel-based processes with database systems that are accessed online via a simple web interface. By reusing functionality and repeating common patterns this can be achieved more quickly and cheaply than the configurable or off the shelf options. Larger projects involve introducing and supporting more complex applications and managing requirements into a programme that can be confidently delivered. We also provide other software companies with support, typically where it is an unfamiliar area or to deal with busy periods.
Increased Automation - Reduced Admin and Clerical Costs
Increased Flexibility - Software tailored entirely to your needs
Competitive Advantage - Custom software can set you apart from everyone else
Expansion is possible - Add more features to the software as your business grows
Related: "Modify Software", "Macros", "Scripting", "Formulas", "Bespoke Software", "Custom Software"
- » Java
- » PHP
- » Perl
- » C
- » C++
- » ASP
- » .NET
Algorithm Development and Implementation
Identifying appropriate algorithms is the first thing to look at when faced with a difficult computational problem or a performance bottleneck. Unfortunately with the steadily increasing power of hardware, developers will frequently take shortcuts and use inappropriate algorithms, providing suboptimal (poor) solutions to problems, or introducing future performance problems. As these problems arise, 'quick and dirty' solutions such as a more powerful server, more RAM or rescheduling jobs to allow more processing time to be assigned may be proposed, but they are unlikely to work for long. Looking again at the problem from the start and designing an efficient algorithm may cause more short-term disruption, but once this issue is fixed it will tend to stay fixed. We've designed and adapted hundreds of algorithms for custom requirements and enjoy investigating new design problems involving algorithms and complexity. Once the algorithm has been designed, implementation (coding) is the more straightforward part.
Problem Solving - Identify and analyse with the underlying issue
Long-term solution - Create a solution which will last
Experience - We have designed hundreds of algorithms for varied problems over the years
When designing software or developing a new algorithm, it will typically be tested with a small volume of data to ensure that it provides the correct results, and also that it does so in a acceptable amount of time. This is then used to assess how the software will perform in future. Consider the situation where software is required to assign jobs to engineers to minimise travelling time. It might run in 10 seconds for 10 engineers and 50 jobs, but how would it work for 100 engineers and 500 jobs? Would it take 10 times as long, or perhaps 100 times as long? The time taken for some algorithms grows exponentially as the problems grows. Of course you can just run lots of tests and trend the results, but complexity analysis avoids this. By studying the way that the algorithm works, its complexity can be determined. In the example of engineer assignment you might find that one algorithm's complexity depends on the square of the number of engineers (n), and another depends on the number of engineers (n) multiplied by the number of jobs (j). Depending on the likely use of the software you can then decide whether to use the O(n*n) option, the O(n*j) option or to go back to the drawing board and develop a more efficient algorithm. Working this out clearly up front is much less disruptive than waiting until users start complaining that the system is slow, or the job is taking too long.
Identify problems early - Identify potential problems down the line and action accordingly
Plan long term - Plan around future issues to prevent distruption
Software is often adapted and developed over time for purposes and in directions that were not envisaged when the software was initially designed. Over time many different people may work on one piece of software and do so in subtlely different ways. It may be that 'cut and paste' programming is used, or buggy and hard-to-maintain code is introduced. None of these thing are desirable, but they all lead to a requirement for refactoring the code. This is a process of replacing old code with new code, where the new code doesn't have the same problems, and has been written with the benefit of recent knowledge about the way the software is likely to be used in future. If refactoring is delayed for too long, a situation may arise where no further development can be carried out, and a disruptive full rewrite is needed. We will typically make provision for refactoring when any of the problems mentioned look likely to occur, and by doing so avoid the disruption of a code base that can't be worked on. It is sometimes useful for a 'fresh pair of eyes' to carry out (or at least advise on) refactoring, and this is a service that we are happy to offer to other software developers.
Keep software up-to-date - During refactoring we can incorporate new technologies
Resolve bugs in the system - Can work on bugs in the system whilst reviewing
Fresh pair of eyes - A fresh look can identify issues someone used to the code may not seeRelated: "Rewrite Software"
A typical client would realise that they needed a 'database' when the limitations of paper processes, Excel, Access or similar were identified or started causing problems for their business. Of course, any of those things could be described as a database of sorts, but we are generally talking about a dedicated DBMS (Database Management System). Microsoft Access is a bit of a special case as it does have many of the features of a DBMS, although there are a variety of problems with the way that it is commonly used. There are a variety of different types of databases, but the most widespread (certainly in terms of the number of active instances) would be relational databases, which store data in tables (aka relations) and allow that data to be accessed using SQL. By following accepted practice the data stored in a database will be of greater quality, consistency and integrity than data stored in Excel etc. This provided a solid foundation for standardised systems, processes and automation, and resolves the problems identified above. Of course a database in isolation may be of little use unless every user is prepared to learn (and use) SQL, which is why some sort of 'user interface' is typically provided. In the absence of any good reason to do something differently, most systems that we develop would consist of a database using either the PostgreSQL or MySQL DBMS, and a web-based (though not necessarily Internet-accessible) front end
Increased Automation - Leads to better efficiency and fewer errors with data handling
Data Validation - Other methods can lack validation features, database devolpemnt will improve accuracy of your data
Cost Effective - Less time should be needed to maintain your data
Audit Trail - Every change to the database is logged, and can be referred to when needed
Related: "Data Modelling", "Data Integrity", "Foreign Key Constraints", "Normal Form"
- » Oracle
- » SQL Server
- » MySQL
- » Postgres / PostgreSQL
- » Relational Database
- » Access
- » Excel
The value of a database, web catalogue or shopping site is frequently assessed by the quality of its content. Consistent, clear, correct and comprehensive catalogues are a resource that can be updated and improved over time, whereas a catalogue of poor quality will be ignored and ultimately disposed of. Cataloguing is time consuming, but we can help with the cataloguing itself, as well as by providing systems and databases that hold the catalogue data in such a way that it encourages and promotes the creation of useful and reusable records.
Consistent Data - Structured data is easier to layout on a website or catalogue
Data Accuracy - Checks will be inplace to help ensure data accuracy
Presentation of data - A uniformed structure of data just makes it nicer for someone browsing through it
Every software developer would contend that they deliver software as quickly as possible without recklessly sacrificing quality. This is very similar to George Carlin's observation - 'Have you ever noticed that anybody driving slower than you is an idiot, and anyone going faster than you is a maniac?'. We strike the balance by relying on the experience of our developers and managers. Some requirements really do need exhaustive testing, long trials and large quantities of approval paperwork, while others can progress from requirements to deployment within 30 minutes. We have delivered over 1600 development jobs since tracking began in 2011 over a range of timescales / complexities and our experience in rapid delivery is well reflected in our references and testimonials.
Cost Effective - We will deliver the requirements in a sensible timeframe
Quality - We work fast, but deliver high quality development
Experience - Over 1600 developemnt jobs since we started tracking in 2011Related: "Agile Development", ""
As soon as businesses grow to use more than one system, the requirement from System Integration arises. Most small businesses will use a book-keeping and accounts package, and a separate system (even if paper, email or spreadsheet-based) to co-ordinate operations. As businesses grow the number of systems increases, and the requirement for the systems to be integrated follows naturally from the obvious requirement to work efficiently and avoid manually transferring data around the company. Getting the systems to communicate is hard, and it can be tempting to resolve this by taking a 'comprehensive' range of integrated products from one supplier. Sometimes this works but it can be hard for a business to extract itself from a software monoculture like that. We can help with advice, design and management of the system integration process, and we can also develop custom components that allow the various systems to communicate with each other, even when this communication has not been implemented by the vendors of the two products to be integrated.
Improved efficiency - Limits manually transferring data between systemsRelated: "Configure Middleware", "Build Interfaces"
Perhaps the first thing to be done at the start of a business change involving software is requirements analysis. There are various theories and procedures that may be followed, as well as countless ways of documenting the requirements, but there is no substitute for a series of conversations or meetings with someone who has experience with taking business problems and converting them into a set of requirements. The output of requirements analysis is a requirements document, and after being approved by the stakeholders this can then be used for the estimation and design stages of the project.
Clarity - Both you and the developers know exaclty what the end goal is
Risks identified early - During the analysis, complex issues can be identified and addressed early
Technologies SupportedRelated: "Requirements Document"
Do you need an impartial assessment on a software product or a development proposal? Having been involved in many development projects we appreciate that independent advice is often worth commissioning prior to making decisions on large projects. We can assess various elements of developments at various stages, from the requirements document and design through to the test output, acceptance testing procedure and deployment plans. We can also provide advice on the "pro's and con's" of different licensing models, and on any gaps in proposals that may cause concern.
Indepentent Advice - We can come in purely to offer a second opinion on a current or potential systemRelated: "Code Review", "Due Diligence"
People get used to particular tools and procedures, and can be resistant to change, especially when the reasons for the change are not clear. Regardless of this, a great deal of business change involves changing systems or applications, and trying to do so while avoiding disruption. Sometimes problem applications (perhaps those that are costly or slow) are required by various teams for different reasons, and it is hard to see alternatives to a risky 'big bang' switchover from the old system to the new. Quite often the vendors or providers of the new software don't have this as part of their remit and are reluctant to engage with the detail. We have a great deal of experience migrating users between applications in ways that minimise the risk and ensure that where there are problems, that they are resolved without disrupting the business or the change process.
Experinece - Use our experience to help a smooth transition
Problem Solving - Where there are problems, we will work quickly to avoid business distruptionRelated: "Problem Applications", "Legacy Software", "User Migration", "Unsupported Software"
Most of the software that we produce and are involved with is straightforward and intuitive to use, so producing lengthy manuals that predominantly state the obvious tends to be a poor use of time and money. This changes where the items being modelled, managed or represented by the software are complicated and not widely understood, or where there are specific processes, procedures or conventions that must be complied with, and which the software expects the users to follow. In situations like these the lack of good quality technical documentation (both for users and developers) will lead to spurious support and development requests, and to the system being used in ways that were not intended. We tend to produce technical documentation using the LaTeX document preparation system as it provides clear version control and tracking using git or subversion and the documents tend not to degrade in quality over time in the way that some of the alternatives do (Microsoft Word with other embedded documents for example). By organising technical documentation in tables and using the same structure and representations as the software, the number of problems in acceptance testing and the amount of supervision required during development can be significantly reduced.
Guidance for technical tasks - Where the tasks on the system are complicated, we can provide documents to help
Ease future developments - A useful tool for the next developer who does work on the system
Cost effective - Sound documentation can help limit support and future developement requests
Structured Documentation - Structure helps user find the sections they need in the documentation efficiently
Software testing is a large topic, and the time and cost associated with it tends to increase with the importance, complexity and development rate of the software in question. For small, simple, infrequently-changing projects, a comprehensive set of manually executed 'system tests' is usually sufficient. Unfortunately, as the project is developed, the test must all be re-run (regression testing) to ensure that nothing has been broken unexpectedly. This can be reduced to a certain extent by breaking the software into components that can be tested separately (unit testing), but without automation the time and associated cost quickly increases the minimum cost for each development. By automating some or all of the testing, new features can be deployed to test servers and allowed to execute a full set of tests that will not only check that the new features are working, but also that none of the existing features have been inadvertently changed. We use a variety of tools for this, generally with different approaches for system testing vs unit testing, but both types can be successfully automated, even if the software hasn't been written in a way that facilitates that.
Error Finding - The obvious benefit for testing, is locating errors in the system
Automated testing - With regular tests run, it can save having to write new tests for every development
Introduce new features safely - Can valiadate that you are not breaking other sections of the system with new changes
Unfortunately many businesses are reliant on software that is no longer supported and consequently can't be improved or modified. The software frequently uses custom file types and formats and the source code is either not available or is written in an obscure or otherwise undesirable language. In cases like this, reverse engineering techniques can be used to produce a compatible replacement for some or all functionality provided by the unsupported software. There are no general procedures that work in all cases, but using a combination of tools and experience with the languages and techniques used to build the software may allow for a suitable supported replacement to be produced. There are legal issues around reverse engineering, which must be properly explored before each project is started.
Stay relevant - Don't be forced to rely on outdated software
New features - Ability to add features to a current system where it wasn't possible before