Five steps to tell you how to develop a Web application

This is a question that is often asked and rightly asked. As a programmer, why should I be considered to know how to develop a Web application? There is no simple answer to this question, and even those educational institutions may not be able to know it clearly; The university I was on did not offer any courses on the subject. So, like most web developers in the field, I just learned this by doing experiments. No one told me how to do it, I started by doing something for myself, learning how to develop Web applications is a byproduct of this process. This is a very effective way to learn any language.

You're lucky that I'm here to talk about the main process of how to develop a Web application. Hope to help you get started. `

The difference between a Web application and a Web site

First, I would like to say that developing a Web application is not the same as developing a website. While there is a big similarity in general, there is a huge difference in the time it takes to develop them. So what's the difference between a Web application and a Web site? In general, Wikipedia can help us explain this, so let's take a look at how Wikipedia defines the application software:

Applications, often referred to as applications, refer to computer software designed to help users perform one or more related specific tasks. Enterprise software, accounting software, office suites, drawing software, media players and so on belong to this software.

In contrast to application software, system software and middleware, which manage computer performance and how management integrates with computers, are often not directly reflected in the execution of tasks that benefit the user. For example, a not very appropriate entity analogy, the relationship between the application software and the system software is like the relationship between a light bulb and a power plant, the power plant (System software) just produces electricity, it does not have any real use, unless the use of a light bulb such an application tool to provide services to users.

From the inside, I summed up my own definition of the Web application:

A Web application is a Web site that enables users to accomplish certain tasks. The main goal of an ordinary website is to provide information (blogs, news, guidance, etc.) to the user.

The development process of Web applications

Now that the features are clear, we can start defining the entire process of developing a Web application. Of course, this depends on the size of the project, some steps in the process may be small, in your mind can complete the work, but it is always good to know the whole thing. It's also important to understand that this article does not have a deep-seated description of each step.

Step One: Analysis

The first step in developing a Web application is to analyze your needs. You should now define a list of features that your app should provide as comprehensive as possible. If you do these things for a client, you need to understand what they want (make sure you know what the other person is saying). From your discussion, you can summarize the requirements and software specifications. Even if you're developing for yourself, I suggest you write down what you want the Web app to do.

Step Two: Design

Once you've figured out what this web app needs to do, you can start designing. This step is often repeated several times, each time the design is refined some. The first thing you need to do is draw the page flowchart (draw on paper, or use the software tools, with each one well.) I like to use paper so that I can change it more quickly). A page flowchart is usually a very abstract black-and-white painting, drawing the look of the Web app you're going to implement (you can add some color, but keep it simple).

This step will let you know what your app will look like in the end. Contrary to the 37signals initiative, I suggest using some words to describe, moderately refined. When I think of a good idea, or think about how things should be done, I'll label it on paper (for example, when you click this button, you should make another element change or hide, and I'll write it on the flowchart).

When you are satisfied with the sketches you have made, you can start making the solid model.

The solid model is still patterned, but with color and detail. The final entity model should look like a screenshot of the Web app you're about to implement. If you develop for a customer, he will look at these things and give you his approval. However, many people like to skip this step (most of them are non-designers) and they like to go straight to the Web prototype.

Prototypes are developed in HTML and are rendered using CSS (and sometimes JavaScript). Page layout to do, links can point, color, font, font size to set up (if you do a solid model, this will be easy). This step is very important because everything here can be used in your final application. If allowed, do some usability testing on your prototype, which, in the long run, will prevent you from making a lot of mistakes.

At the end of this step, you'll basically know how your web app is organized together. The login page has something to do with how the user can move from the home page to individual pages.

Step Three: Achieve

Select a Frame

Now that we know what to develop, we need to make it happen. This part is a lot of work and you spend most of your time on it. The first decision you have to make is how to get started, what kind of technology to use, what framework. You have a lot of options and you need to pick one that suits you. The following is a list of the most commonly used frameworks:

asp

A framework for any process on PHP

Python with Django

Ruby on Rails

There is no clear standard to say which framework is best. They are all different, each with their own strengths. The most important thing is that you have to know that any of them will allow you to develop useful Web applications.

Development

Once you know how to develop it, you have to get rid of your arm and start working. This development work can be seen as a lot of blocks, but after all, it's standard programming activity. In the background, you create classes, objects, services, procedures, and persistence layers to save these objects to the database. The background is the core of the entire application, and it is no different from normal programming for any application. Next is the development of the foreground, the code that you are writing now is the user interface that is really to use. You integrate the back-end program with the prototype interface to bring together the parts of the system. You can also use JavaScript for some of the cool little features you think of during the development process.

Again, there are many ways to implement a background program. It is recommended that you read the information related to the framework of your choice and figure out how to accomplish this part of the work. Typically, this knowledge is related to object-oriented programming, but some frameworks are slowly moving toward domain-driven design.

Step four: Grinding and polishing

Now that the application has been developed, individual modules are integrated. You need to pass the test to make sure that the requirements and software specifications that you defined in step one are implemented (the problem is in your mind throughout the development process). You want to make sure that stupid users can't break your app by trying to do something you haven't done yet. You also have to make sure that your program works correctly in a variety of browsers (hopefully not IE6).

It is also time for you to make some small tweaks to improve your application to give people the feeling that it tends to be perfect.

Step five: Release and follow-up work

This last step, but not the end, is to publish your app so that the user can really use it (if the app is a public-developed app, don't forget to do the news). If you want to, publish a beta version, so only a small number of users can find the big problem in your app (because there are sure to be bugs in your program), they will help you improve the quality of the program. Don't be too busy adding functionality, focus on getting your current program to be solid.

After the beta phase, your program has become very solid, listen to user feedback, try your own application, you can start to think about how to make the application better. Find out where the disharmony is and eliminate it. Each iteration will go through the five steps described above, but as I said initially, you now have a running application that you can easily complete directly in your mind and run directly into the code to test your functionality.

