So, when you download and install Visual Web Developer, it comes with and MSDN Express Library which allows offline access, MicroSoft SQL Database, the .Net framework and SDK, and a small Web server for you to view your web pages locally.

With the web development environment you have many options and services.  The two main programming languages that come with the 2008 package are Visual Basic and C#, but you can also use C++.  There is a help menu and a Get Started tutorial.  One of the first things you will notice is what would be your index.html in most platforms, is called default.aspx in Visual Web Developer.

In the IDE there is a source view and a design view, which is pretty standard for most development environments these days.  You can also have a split view.  The design view is cool because you can type text into it, drag and drop HTML controls like text boxes and buttons without typing the tiniest bit of code.  It is all done automatically.  The same goes for table generation.  It’s done with a few clicks.  Also, in the design view you can easily resize images by dragging the edges.

You will eventually have to type some code, but this is made easier by IntelliSense, a feature that can finish off your code wording for you.  This can help avoid the annoying misspellings when it comes to debugging time. IntelliSense is useful with VB and JavaScript as well.

The Solution Explorer window allows you to create and browse directories, and organise your web documents.  For example, you can create an image directory and then browse images on you computer to put in this new directory.

Other automated features include building the site, debugging option before playing the page, a built in web server that requires no configuration on your part,  and a manager for copying your site and connecting to a remote web server.  Note that this remote web server has to be IIS.

Along with all this are a plethora of templates.  The amount seems daunting at first, but the main ones are:

• Master Page for setting a format for multiple pages in you site.
• Ajax templates for leveraging Ajax in .Net applications.
• JavaScript template.
• Default HTML template.

You can also customise your environment by setting layout of windows and tools,  and setting fonts to name a couple.

There is also a CSS management menu that allows you to preview CSS styles before attaching them to a default.aspx page.  You can hover over a style in the CSS menu and reveal the code associated with this style.  Attaching a CSS stylesheet is also automated.  You don’t ever have to worry about typing this stuff again.

The last automated feature I am going to talk about is the Data Source configuration and usage.  There is a wizard that gives you a view of all the possible data storage devices on you computer.  You can choose whatever database you want and the wizard will connect your pages to it.  There is also an automated query builder that helps you create SQL queries.  You never have to remember SQL syntax again.  You can even create a nice looking grid of your database for the users to see with a simple dialog box and a few clicks.

In summation, Visual Web Developer is among one of many development environments that can help get the job done quicker if you know what you are doing. With that being said, it is also great for those that don’t know much about web development and want to get started on creating basic web sites.

DOM storage has been developed to overcome the limitations of cookies.  Its proponents claim that DOM storage is useful because “no good browser-only methods exist for persisting reasonable amounts of data for any period of time. Cookies  have limited capacity and provide no support for organising persisted data, and other methods (such as Flash Local Storage) require an external plugin” (https://developer.mozilla.org/en/DOM/Storage).

Some argue that they don’t really see the point of storing persistent data on the web browser.  This limits access to this data from only that browser.  A user or developer would always have to be using the same computer and browser in order receive any real benefit from the DOM storage.

I used DOM Storage in my first assignment.  While it provided a quick storage solution, I soon realised the above drawback and decided that I needed to find another way for storing persistent data.  When I did my second assignment, I used MySQL for storage.  In one of my previous blogs, I mentioned the concurrency problems I was having.  The design of my website was causing multiple processes to simultaneously access and modify the database.  This doesn’t work.  This is where DOM storage could possibly help.  I could have temporarily stored the new data in the DOM storage and modified it from there before sending it off to the database.  This would have solved my concurrency problems.  So that is just one possibility of DOM storage.

There are probably many more possibilities with this feature.  I don’t really see the point of using DOM storage for persistent data besides using it for huge cookies, which might be a reality in the future, especially if companies don’t want to store and organise your buying and browsing habits on their databases.  DOM storage does seem like a good storage device for temporary usage during a particular session.  So take a look at DOM storage.  It’s rather easy to implement and it could possibly prove useful.

• No greater-than (>) nor less-than(<) symbols in the title.
• No escape characters (\) in the title.
• Trim all leading and trailing whitespace off of the title entries.

This is just the beginning of protecting against XSS attacks.  The other issues to consider are database attacks.  It would probably be wise to disallow entries like “DROP TABLES;”. There are a myriad of attacks and vulnerabilities that web browsers are susceptible to.  It is up to to the web developer to be aware of the latest attacks and security measures.  While a web site with a Cornell Notes title does not pose the biggest risk, it serves as simple example and reminder of how easily fooled web browsers really are.

This project worked much better than my first attempt using client-side persistent storage.  The DOM storage thing is not very cross-browser friendly.  With Ajax and server side storage everything seemed to work perfectly.  The only issues I ran into were concurrency problems and retrieving information from the database that had HTML tags around it. 

As far as the concurrency issues went, I never really solved them.  I was trying to access and manipulate the database from two different functions at almost the same time.  JavaScript doesn’t provide a wait() method.  Well, it does provide the setTimeOut() function, but that only stops the function that it is applied to.  The parser continues down the page and still executes the subsequent code.  So, this didn’t help me.  And believe me, I tried to make the setTimeOut() work.   PHP probably has something to help with this, but I didn’t have time to explore that route.  So, I had to give up on some functionality because of this concurrency issue.

The other issue with the database retrieval of HTML tags was simply solved by JSON.  I didn’t have to do any DOM parsing with JSON.  JSON just serialized the data and dumped it right into tinyMCE without any problems. It took me awhile fidgeting around with the PHP echos from an XML page before I finally tried JSON.  It would have saved me so much time had I went with JSON from the start.

1. Core:  The Core component is for event management and DOM manipulation which include the Global Object, DOM collection and Event Utility.
2. Utilities:  The Utilities component includes resources for animation, browser history manager, a connection manager that helps manage XMLHttprequest, cookie management, drag and drop ease, and a JSON utility for validating JSON and converting Javascript data into JSON. 
3. Controls:  The controls component provides AutoComplete for user interaction involving text entry, buttons, calendar, charts, color selection, layout manager, rich text editor, and an uploader that allows multi-file file upload. 
4. CSS Resources:  The CSS component provides CSS fonts, Grids, and standard base of CSS rules.
5. Developer Tools:  Provides a logger that has an effective debugger, a code profiler, and YUI Test that allows you to add unit testing.
6. Build Tools:  Provides a YUI Compressor which minifies Javascript and CSS, and YuiDoc which generates organized, searchable API documentation.

How does YUI compare to jQuery?

YUI’s debugger is advanced and sophisticated and allows you to debug in IE where Firebug cannot be used.  Another thing that seems good (which to some may seem like a drawback) is that YUI does not create a new language as much as  jQuery does.  JQuery is easy to use and great for rapid prototyping, but you don’t need to know Javascript in order to use it.  This could cause jQuery code to be very inefficient if a developer does not know what they are doing.  YUI looks like Javascript and, thus, requires the developer to understand Javascript.  This makes YUI a bit more difficult to learn as it is more verbose than jQuery, but it can be worth the investment in the long run as your code is likely to be more efficient. 

jQuery is much more popular than YUI and has excellent community support.  Where YUI seems to dominate is that it has better UI features and components, its library is much more complete and very well documented.  The jQuery library is not full featured without plugins.  I have seen complaints about  the plugins being somewhat inconsistent depending on the author. 

Despite that fact that YUI lacks the elegance of jQuery, it is gaining popularity because of the richness it provides.  If you don’t care so much about what is going on “under the hood” and want instant gratification, jQuery is probably the way to go. But, if you want to understand what you are doing and use a more complete library, YUI might be worth looking into. Either way, they are both awesome resources for creating rich web applications.

Applications can be run in either the Java runtime environment or the Python runtime environment. Google App Engine provides a data storage service that is not like a traditional relational database.  The data stored is structured by the application code used by the developer.  The Java Data Object, Java Persistence API, and the Python datastore interfaces can be used to create this structure.  The benefits of these interfaces, like JDO, allow the developer to focus the domain object model instead of worrying about persistence details.    JDO is provided by the Data Nucleus Platform, an open source provider of products for the management of data.

If you like Java, App Engine is especially suited for development using Eclipse.  You can download plugins for Eclipse, and off you go.  If your not familiar with Eclipse, the configuration may take a few moments, but after that the WAR files are all set up for you automatically.  There is a great tutorial for creating and uploading an application using the Eclipse IDE at:     http://code.google.com/appengine/docs/java.

I am not familiar with Python, but I imagine that the runtime environment is geared towards rapid development also.  Like Ruby on Rails, the App Engine takes care of data storage and common tasks and allows the developer to focus on the custom features of her application.

As with most of these IDEs, the biggest hurdle is the learning curve.  Once you are familiar with the environment, everything starts working like clockwork.  I am more familiar with Java, so for me, the App Engine seems like the better option.  While Ruby on Rails provides an awesome rapid development environment, it’s syntax and style is still quite unfamiliar to me.  Also, I like that the App Engine allows me to share up to 10 applications with the world.  That is a pretty awesome feature.

Ruby on Rails adheres to the Model View Controller (MVC) framework, which is a way of breaking an application into 3 different parts.  Model is used to manage information and changes.  The View is used for mapping graphics onto a device, and the Controller is the means by which the user can interact with the application.

ActiveRecord, which represents the Model, maintains a relationship with the classes and database.  It handles all the transactions with  the database.  It removes all the tediousness associated with verbose SQL commands and queries.  ActiveRecord allows the storage and retrieval of objects by providing an interface between the tables in a database and the Ruby program.

Another thing to note are the naming conventions in Ruby.  Local variables are made up of lowercase letters with words separated by underscores.  Instance variables start with an@ symbol.  Classes use mixed case, where each word starts with an uppercase letter.  Database tables are the same as variables except that they names need to be plural.    There are many more naming conventions.  A more complete list can be found at:  http://itsignals.cascadia.com.au/?p=7.

1. I am extremely interested in persistent storage.  I want to become more familiar with MySQL and its usage with programming languages, namely PHP.
2. I want explore JSON and XML more in order to discover their strengths and weaknesses and how storing them in a file compares to storing elements in a database.  That probably means that I need to become much more familiar with Ajax.  I understand little bits of each of these entities, but I don’t yet see the big picture.
3. I have come to respect jQuery as an important web development tool.  Cross-browser issues are really annoying.  Can’t all the browsers work the same?  Well, jQuery seems like the best solution so far.  It’s syntax is still a little foreign to me.  I guess I’m used to seeing long lines of code that tell me exactly what is going on.  It’s big adjustment to look at small amount of code that can do so much, especially where events are concerned.
4. CSS has so much to offer. I haven’t even begun to understand all that it can do.  My website is an obvious testament to that.  I look forward to the day that I am pleased with the aesthetic appeal of a web page that I have created.
5. I want to get more acquainted with JavaScript.  Of all this web stuff, JavaScript makes the most sense to me.  With a little more practice, I should be pretty quick and clean with this language.

The list goes on and on.  There is so much to sort through and experiment with.  It’s overwhelming because I have to understand a lot of it real quick in order to get a mark.  It’s exciting because I now know that so much is possible with web development.

 I found a plethora of information from many sights and blogs concerning all aspects of my website.  I also spent a fair amount of time working with TinyMCE, even though in the end I went with a simple set up using my stylesheet.  There is a tinyMCE forum that was quite helpful.  I also received a lot of helpful information at tizag.com.  While I mostly researched JavaScript on this sight, it has a wealth of information.  I also spent some time using  the jQuery site.  This is a great sight and I expect to visit it many more times in the future.  I’m just beginning to get comfortable with the idea of using jQuery.  I only used it  in my FAQ page which made things very simple.  Of course, W3CSchools was always there for handy questions and references.  I also went to books 24/7 a lot to look at the two books referenced in class.  This proved to be a great resource.  

So, if I had to choose my top 4 sites  for this assignment (excluding all the random blogs and forums), I’d have pick the following:

http://www.tizag.com/javascriptT 

http://www.books24x7.com 

http://www.jquery.com