8 prime rules for rapid development and design

Today I read an article written by David Martin. Article I thought it was good. I wanted to translate it completely, but it was time-consuming. The next lesson had a compilation principle, and the teacher was too abnormal. If I didn't go to the class, I was absolutely scared if I was found to miss a class once. The following describes the eight golden rules:

1. Avoid rendering HTML from. Net code.
Avoid Code Output html
2. Avoid rendering HTML from JavaScript.
Avoid HTML output in JS Code
3. Avoid in line ASP. NET
Avoid using embedded Asp.net code
4. Do not save formatted ASPX page in Visual Studio
Avoid saving the formatted ASPX page in Visual Studio
5. Developers keep their own working copy of the site
The designer keeps a backup of his website.
6. Release the code behind DLL or code by side files to the designer
Place the released code in a DLL or a file unrelated to the designer.
7. agree at the start of the project the folder structure
Follow the folder structure at the beginning of the project
8. Document A development site map as early as possible
Write the development site map document as soon as possible

A lot of things can be understood when you read English, but it is difficult to translate them into Chinese. It seems that the English document is provided for your reference.
 

We can access any information within seconds-the Internet expectation is fast. for each clients, businesses and management the development expectation is also fast but the reality can be slow and disappointing with unexpected costs or delays. some of the key reasons are frequently poorly understood/communicated requirements, change of mind with look and feel, a system issue or browser compatibility issues.

There is another way-it can be easier!

This series of articles attempts to expose why this happens, provide proven solid guidelines for all involved in the development process and finally best practice approach.

This article will discuss the difficulties of a professional web development team focusing on the integration between the system/code and the UI/design. one of the most subjective elements to a client is the aesthetics which shocould be quick and easy to alter, unfortunately on enterprise scale web applications with developers and designers working together these small quick changes frequently BEC Ome larger changes resulting which during the rush nearing release cause other unexpected faults further delaying the delivery-Sounds familiar?

To ensure we fully understand the problem lets introduce a fictional Web team, called them the yellow team.

To set the scenario...

The yellow team deliver high availability, enterprise scale web sites expecting large numbers of user say 6 + million a month creating 50 + million page views. the yellow teams system Web developers pride themselves on the high performance of their complex web application-sub second database queries from Terra bytes of data, intelligent Ajax callimproving the experience for the user, powerful Seo, etc, etc.

The yellow team UI designers pride themselves on all their applications being sleek, simple, easy to use, great on the eye, quick to download from a graphical perspective, built with the latest CSS techniques, small Quantity of HTML, high flexibility to amend the style and accessible to all (DDA ).

The two different groups within the yellow team need totally different skill sets to deliver the best product possible. The problem is how does the developer group help the designer group and vice versa.

What are problems faced by our yellow bunch?

Different software tools,The developers are using Visual Studio 2005, the designers wont look at this they use Macromedia Dream Weaver and Adobe Photoshop. sharing files between the two is not always smooth, an addition line or a table inserted when the designer expected Div tags to maximize CSS or a change to the doc type or use of a different tag option such as <B> or <strong> etc, is not very helpful and creates frustration, repeated work and delays.

JavaScript styling , to create the usability required JavaScript will be found somewhere on the site. in our cases the developer makes a demo-to embed HTML to render out within the JavaScript code, it was a quick and easy solution for the developer at the time. when the designer wants to change the look and feel their design tools are no help. it may not be clear where this HTML is coming from, they have to trawl through the JavaScript and manually make the changes. this is not an issue if your designer writes the Javascript, however if you take the view that the Javascript is a key part of the application and shoshould be authored with the same discipline as SQL or C #/vB business logic then it is likely that the developer owns the JavaScript.

Asp. net server controls are definitely great however used with out thought for design they can be a big issue. if the specified action should des HTML rendering it may be difficult for the designer or impossible to change the style. this limits the use of the control-CES its reusability and delays the development of the project. in some cases the developer (who may not be a UI expert) has embedded font tags in the HTML within the control; this will make life hard for the designer.

To summarise so far all web projects suffer the same project management challenge-aesthetics which are highly subjective. this results in often unavoidable changes at worst time-the end. what might be a small aspect of the UI cocould unfortunately for the Web team and the PM result in changes in server controls code behind changes, re-compilation, JavaScript alterations etc. whilst this can be done it is not efficient, will take time, cost money and potentially delay a project.

Some good guidelines to consider which may cause radical change in your development depending on your current approach are :-

1.Avoid rendering HTML from. Net code.

This is a huge gotcha to avoid! Where code behind exists avoid rendering HTML tags from the C # Or VB. net. stay well clear of response. write etc. the use of containers such as Divs ,. net place holders controls, repeater controls etc will allow the content to changed from the code isolated from the style. it may seem easier but don't do it! The times when HTML tags must be rendered from the code behind be sure to sit down at design time with your designer and identify where the ability to set a CSS class name attribute wocould be advantageous to designer and then make sure you expose the ability to set the CSS classes easily without needing code behind or Visual Studio, the best way is to expose a property which can altered as an attribute in the Aspx.

2. Avoid rendering HTML from Javascript

Very similar to rule one, don't do it! The designer will not be able to function quickly if they need to search through an array for the tag they need to change or get the source to a reference Javascript file and change a tag embedded in function. again there are better ways-a simple Div tag used as a container wowould probably do the task or in parallel cases the use of CSS cocould replace lines and lines of JavaScript. if style related elements have to be in the Javascript then use good programming practice-meaningful variable names, comment the Code etc.

3. Avoid in line ASP. NET

This means don't use <% some. net code %>. this is a really flexible, quick, easy way for the developer to implement a change (or hack it, If you as me) but it will bite you back later! If we skip all the good programming reasons to avoid this practice in a large enterprise application and focus on the designer it really will not help them. the tool may not (later versions of Dreamweaver supports. net) support the <% tag it etc. it is not friendly! \

4. Do not save formatted ASPX page in Visual Studio

This is slightly unfair to Microsoft, VS 2005 is a lot better and does not normally chew up the HTML and spit out its own additions. vs 2003 did! The frustration caused when a page has been designed and a code bug needs fixing so the developer fixes it resulting the well designed page no longer looking as the designer intended must be huge! This is the key problem to avoid anything that aggravates this issue shocould be avoided!

5. Developers keep their own working copy of the site

It may feel like an additional administration overhead but it saves a lot of time if the developer can work freely in the knowledge that he can not affect the files worked on by the designer. I have seen it work very well were the developer version has little or no CSS so the page layout is simple and obviously not designed. this provides the additional benefit that management will not feel the product looks ready and want to go live. it controls acts functionality design from look and feel focusing the entire teams mind on usability which a very good result.

6. Release the code behind DLL or code by side files to the designer

Let the designer own the final release version, release to them the updated code behind DLL or code by side files. they can replace these files on the solution knowing no HTML was affected. this shoshould mean the developer has tested their code and release it knowing it works.

7. Agree at the start of the project the folder structure

When under pressure time is not always available to tidy up the structure where developers and designers had used different structures etc

8. Document a development site map as early as possible

Define in a few lines each pages that will be used an their names following a consistent convention at the very start if possible. include pages which the user may not navigate but the designer and developer will use such as a pages which redirect, custom error pages, security authentpages, pages which are used in iframes, pages used by Ajax, pages or file extensions which are not standard such as image handlers or dedicated Seo pages.

Keep the development site map up to date. Add any config files and detail regards expected parameters on the query string for pages etc.

This application Bible will reduce questions bouncing the team, reduce repetition and help project management understand the overall progress of the project.