What is web software development?
Web software development is a process of developing software or web script through successive phases in an orderly way. This process includes actual writing of code as well the preparation of requirements and objectives. The design of what codes to be written. Confirmation that what is written has met objectives.
Before software and online scripts development methods came into being, the development of new systems or products was often carried out by using the experience and intuition of management only. However, the complexity of modern systems and computer products made the need clear for engineering process of software.
Typical phases of web software development:
- Identification of required software
- Analysis of the software requirements
- Detailed specification of the software requirements
- Software design
The development of commercial or open source web software is usually a result of demand in the marketplace, while custom software development generally rises from a need or a problem within the enterprise environment.
How is software development guided?
The software development process is almost invariably guided by typical engineering method. It includes process models, development guidelines, and systems development life cycle models (SDLC). Web software development methods nevertheless generally include the same development phases:
- Existing web software or web script is evaluated and its deficiencies identified through interviewing system users and support personnel.
- New requirements are defined. In particular, the deficiencies in the existing system must be addressed with specific emphasis towards improvement.
- Plans are laid out concerning the physical construction, hardware, operating systems, programming, communications, and security issues.
- The new components and programs must be obtained and installed. Users must be trained in its use. All aspects of performance must be tested. If necessary, adjustments must be made at this stage.
- The new system can be phased in, according to app or location, and the old system gradually gets replaced. In some cases, it may be more cost-effective to shut down the old system and implement the new system all at once.
- Once the new system is up and running for awhile, it should be exhaustively evaluated. Maintenance must be kept up rigorously at all times. Users should be kept up-to-date concerning the latest modifications and procedures.
Web software development life cycle model is developed as a structured approach to information system development that guides all the processes involved from an initial feasibility study through to maintenance of the finished application. Web software life cycle models can take a variety of approaches to development.
Web software development life cycle models include:
- The waterfall model: This is the classic model, with a linear and sequential method that has goals for each development phase. The waterfall model simplifies task scheduling, because there are no iterative or overlapping steps. One drawback of the waterfall is that it does not allow for much revision.
- Rapid application development (RAD): This model is based on the concept that better products can be developed more quickly by: using workshops or focus groups to gather system requirements; prototyping and reiterative testing of designs; rigid adherence to schedule; and less formality of team communications.
- Joint application development (JAD): This model involves the client or end user in the design and development of an application through a series of collaborative workshops called JAD sessions.
- The prototyping model: In this model, a prototype (an early approximation of a final system or product) is built, tested, and then reworked as necessary until an acceptable prototype is finally achieved from which the complete system or product can now be developed.
- Synchronize-and-stabilize: This model involves teams working in parallel on individual application modules, frequently synchronizing their code with that of other teams and stabilizing code frequently throughout the development process.
- The spiral model: This model of development combines the features of the prototyping model and the waterfall model. The spiral model is favored for large, expensive, and complicated projects.
How has the open source development process influenced software development in general?
Open source software is developed collaboratively; source code is freely available for use and modification. The open source movement arose because some web developers came to believe that competition amongst vendors leads to inferior products and that the best approach to development isa collaborative one.
The OSI (Open Source Initiative) is an industry body that certifies products as open source if they conform to a number of rules:
- The software being distributed must be redistributed to anyone without any restriction
- The source code must be made available (so that the receiving party will be able to improve or modify it)
- The license can require improved versions of the software to carry a different name or version from the original software
The biggest influence that open source has had on web software development in general may be through competition: by competing with proprietary software products, open source products force vendors to work that much harder to hold their market share in the face of viable open source alternatives.
What are some generally accepted best practices common to web development models?
Here’s a collection of some of the top tips from a variety of industry sources:
- Make sure that you’ve chosen a systems development life cycle model that suits your project, because every one involved in the processes depends on the model. Much of the success of a project depends upon how scrupulously the model is adhered to.
- Reuse software components when it’s appropriate, but don’t use code that doesn’t work perfectly for its intended purpose just because you have it on hand.
- Be very thorough in gathering requirements, ensuring that all parties agree on what they are — and make sure you document them.
- Don’t promise the world, if you can’t deliver it. Avoid letting someone who isn’t fully informed negotiate with the client.
- Make sure that the architecture you’ve chosen is appropriate for the application you’re building. To retain perspective, you might want to plan the architecture incrementally.
- Change is part of life, including software development. You have to accept that various things — requirements, for example — are likely to change throughout the life of the project. Keep control of them, but not too rigidly.
- Set up peer review processes for every element of the project.
- Design thoroughly and with care, but remember: Keep it simple.
- Split big projects into manageable chunks, with concrete milestones and deadlines.
- Ensure accountability: make sure that deadlines are clear and that people have to report on whether they made them, and explain why not if they don’t.
- Implement quality control procedures throughout the project.
- Test exhaustively — there’s no point in doing a cursory run through only to have an application fail when you run it for the client.
- After the project is completed, conduct a thorough test. Find out what worked well and what should have worked differently, and your future projects will benefit.
What are some common mistakes in web software development?
According to a Standish Group report, corporations in the United States spend over $275 billion every year on software development projects, many of which are doomed to failure. Research by the group found that over 80% of projects fail for various reasons, and that fully 30% of projects were cancelled prior to completion because of poor execution.
The most common project problems are due to failure to manage project elements successfully:
- Requirements are not clearly and accurately defined, and agreed upon by all concerned.
- Resources are not adequately planned and allocated.
- Threats to project success are not clearly detected, identified, and protected against.
- Critical path analysis is omitted, or poorly executed.
- The project’s progress is not tracked adequately.
- Quality management is not carried out well enough throughout the life of the project.
- Too little data is collected, or data is ignored or poorly understood.
- Correcting flaws identified during software security audits is expensive and time consuming. Worse, vast resources are spent on containing and recovering from exploits. Fortunately, providing development staff with the knowledge and tools to avoid many of these pitfalls is easy and inexpensive.
How do you choose the right programming language for a web software?
For most projects, the right language is easy to choose. Your company may have standardized on a particular development environment and language. Or you may be updating or enhancing an existing program; it’s almost always best to use the same language the existing program is written in. In some cases, however, someone will need to select the best. In some cases, you or your team of developers may need to know several languages for different purposes.
General truisms about programming languages are that:
- PHP is most popular and suitable for any project with a lower budget. It’s open source and without licensing costs involved. Design Toronto Web DTW uses mostly PHP as its development tool and uses open sources such as WordPress web development to make projects more cost effective.
- Visual Basic is most suitable for relatively novice programmers and relatively simple programs.
- Java, C++, or comparable languages like Python and Tcl are most suitable for larger applications using object orientation as a design model.
- C is most suitable for programs where efficiency and performance are the primary concern.
- The appropriate assembler language is most suitable where the program is relatively short and high performance is critical.
Where constraints permit, some programmers may favor one object-oriented language over another (for example, Java, C++, Python, or Tcl). A programmer with skills in C is likely to prefer C++, which combines the proceduraland other concepts and syntax of C with object-oriented concepts.
What are some trends regarding the future of software development?
Blogs – A growing number of big-name software developers are finding they can make better software applications if they share information with potential customers from the start and incorporate customer feedback into development decisions. While developers of games software have used this method for years, business software makers are now also catching on and using blogs (Web logs) as an important part of the development process.
Big-name support for independent software vendors (ISVs) – Big players like Microsoft, IBM, and Sun have recognized that they cannot fill every niche industry’s software demands, so they have begun to actively seek partnerships with small ISVs, in hopes that by encouraging ISVs to focus on niche vertical industry applications, everyone will benefit.
Component-based development – In this approach, software is developed in modules that are linked dynamically to construct a complete application. Eventually, software development may become so modular that even non-IT people will be able to assemble components effectively to create customized web software applications.
Use refactoring tools – The concept of refactoring is consistent with the idea of get something working now and perfect it later approach long familiar to LINUX and open source programmers. The idea is also embodied in the approach known as Extreme Programming. As software applications become larger, better refactoring tools will be required to maintain code bases and identify bugs.