In the past year, Agile development methodologies have moved from the fringes to being considered a mainstream method for software development. The Agile movement started in the late 90′s with the advent of Extreme Programming (XP), SCRUM, DSDM, Feature Driven Development and others. The Agile manifesto created in February of 2001 contained the core principles of Agile development. Why is this important to us?

Agile is important, because in the end, it has helped to bring business discipline to software development. Agile has a lot in common with Lean methods, exemplified by the Toyota Production System. Lean methods have begun appearing in Agile teams, bringing even more business focus to software development/IT teams.

Comparing Agile against what?

When discussing Agile, what are we comparing it against? I am comparing Agile against strict Plan driven development approaches. Often called waterfall, your company may not have a specific name for it. But if the current process involves making sure that all the requirements are nailed down before the project is started, and changing those requirements includes a request to walk on water before it can be changed this is the process we are comparing Agile against.

To get a sense of the high level view of Agile you can read the manifesto at AgileManifesto.org. The manifesto begins with four statements:

• Individuals and interactions over process and tools
• Working software over comprehensive documentation
• Customer Collaboration over contract negotiation
• Responding to change over following a plan

These statements may seem a little touchy, feely, so let us put some meat on the bone, to understand how to implement this in your shop.

For each of the statements in the Agile manifesto, concrete practices from Agile methods are used. Each statement is a section that will contain what practices are used to achieve the intent.

Individuals and interactions over process and tools

This statement may indicate to you that Agile has no process. In fact I have found this to be far from the truth. Agile does not throw process out the door, rather Agile says that Individuals and interactions trump the process and tools.

This shows in the frequent planning and daily standup meetings common to most Agile methods. In XP, Scrum, Lean the daily standup meeting is a staple. At this meeting all committed team members interact with each other via these questions:

1. What did I do yesterday?
2. What am I working on today?
3. What is blocking my work?

The daily standup should help communicate project progress. In other words, what is communicated in the standup (individuals AND interactions), may need to supersede the project plan. It is during these meetings that hurdles are uncovered. But usually they are discovered in time to fix the problems quickly. If a technology is not working as expected, or the business logic actually conflicts with other logic, it is brought up in these meetings, and after the meeting the action plan is created.

Working software over comprehensive documentation

This phrase is best described by the practice of delivering software on a regular, fairly quick schedule. Normally in XP and Scrum, you work in iterations. The team selects the length of the iteration at the beginning of the project, and generally stays with that length for the duration of the project. Within an iteration, the team selects the stories or features they will complete. Once in that iteration, the stories that are being worked on cannot be changed. Any changes can be introduced at the beginning of the next iteration.

Normally, at the end of the iteration, there is a demo and planning meeting. In this meeting, your team demos the solution including the new features/stories to the stakeholders/customer. The intent is that if the customer likes this, the team could release that version of the software immediately. In practice this can mean that the team releases the software to QA or User Acceptance state where customers can test/use the new features. Other teams may release to production (think of all the google beta software you have used).

One note on iterations, the length is generally considered to be 1 week to 1 month. This is up to the team. Again, this decision should be made as a self determining team, it should not come from management.

Many Lean/Kanban teams do not use iterations, but they do frequent releases. The releases happen on a similar schedule as iterations. This allows the Lean/Kanban teams to release working software frequently.

The reason for valuing working software over detailed and comprehensive documentation is that the value delivered is the software. Documentation of your system should be baked into the process of delivering software. Agile does this, by encouraging good software engineering principles like Test Driven Development using automated unit tests and automated user acceptance tests.

Test Driven Development using unit tests, and acceptance tests, encourage test writing that serve as documentation. A well written unit or acceptance test should document the requirement the developer is testing for. When any maintenance is needed, different developers should be able to look at these unit tests and understand the requirements needed.

In addition, this suite of tests add a fantastic safety net for modifications later in the life of the software. If the software sits for a year before modifications, the new team can start development on new features, knowing that those tests ensure that they cannot break existing features.

Figure 1: Example of what unit testing frameworks look like

Customer Collaboration over Contract Negotiation

In many plan driven environments, the customer sits down with analysts, and they put together a comprehensive document with their requirements. This document is handed over to a vendor or internal IT group, and an estimate is expected. The vendor/IT group can ask questions about the requirements, and once answered, they come back with an estimate.

At this point the customer is done, except for occasional contacts for milestones. Then when the agreed upon time frame is complete, the vendor/IT team delivers the software. For many, this is the first time the customer team has seen the software. In this scenario, many times, the customer asks to add features, or feels that what they wanted was not delivered.

When Agile methodologists talk about customer collaboration over contract negotiation, there is an expectation of close customer involvement. This means in the planning meetings held after every iteration, stakeholders are present. This also means that the customer is expected to assist team members in verifying requirements. So they may need to participate in creation of automated acceptance tests.

These acceptance tests, using tools like fitnesse, selenium, rSpec, define the tests using an agreed upon format. The tests are written in a business like language to call and test the software components that implement the business logic.

In other words, the Customer Collaboration over Contract Negotiation does mean that the customer is more involved with development. The customer commits more than the example given at the beginning of this section. And that collaboration is designed to foster more trust between the customer and development team.

Responding to change over following a plan

This is my favorite statement on Agile. It also cuts to the heart of how a business can differentiate itself over the competition. When your systems and processes are configured to respond to change quickly and effectively, your business has a good chance to prosper and make a difference.

Practically this philosophy means that during the development of the software, expect and embrace changes. In XP, requirements are met by creating them in small sizes called user stories. Other Agile methods may break the requirements into features. No matter what the size of the requirement, each method allows customers to make changes before the start of each iteration.

For example, when working on an ecommerce site, one of the requirements may be that a customer of the site can bookmark the product, to be available in their shopping cart after they come back, in 1 day or 1 year. At the beginning of an iteration, the customer has a new requirement. Their research indicates that a new feature that adds a recommendation engine to the site will increase sales. During the planning meeting the customer now asks to put the new feature for the recommendation engine as the first one to work on in this iteration. The team is fine with this, and the customer understands that their other feature may not get in soon or ever.

Taking care of changes so close to the process ensures quick response to customer needs. This allows Agile teams to work without cumbersome change committees, just the stakeholders in the planning meeting.

This does mean that in theory the customer could start out with say 150 stories for their requirements. They could through the course of this process get rid of 100 stories and add 200. But Agile processes are transparent enough to show what the cost of those stories is. The customers in the planning meetings see how much the team completes, and the stories left to complete. When the customer wants to change direction, they can, but then old stories that have not been worked on yet, will be pushed to the back.

As noted above, those stories that do not get into an iteration may never get worked on. During the planning meetings and daily standups, customers/stakeholders begin to see the cost of each feature. As they become familiar with the process, less important features may not be worked on, if there is nobudget. This whole process helps the team focus on features with the most value to the company.

Agile is not Chaos

Through the description of the methods used to back up Agile principles, you see that Agile is not about chaos. Instead the Agile name is pretty apt. It is about responding quickly to change, through a process. And that process is generally about delivering good value to the customer, whoever that customer is.

As Agile methods mature, there is a movement incorporating more lean values and methods into the process. Lean fits perfectly with Agile in its pure sense, and helps focus the teams even more into the business side of software/IT. In the end, the focus is about your customers, and your people. Agile is a way to get there.

References

Robert C. Martin “Agile Principles, Patterns and Practices in C#”
Mike Cohn “Agile Estimating and Planning“
David Anderson “A Kanban System for Sustaining Engineering“.
Mary Poppendieck and Tom Poppendieck Lean Software Development: An Agile Toolkit

About the Author

Eric Landes is a Project Manager/Project Lead for a large corporate IT department, specializing in coaching Agile teams. He has 4 + years experience using Agile/Lean techniques to bring customer value and a team focus to projects. See his LinkedIn profile for more information

Ref: Developer.com

Writing a technical document is hard. Reading a poorly written technical document is harder, and probably more painful than writing one. It takes a lot of work to create a clear, accurate, engaging piece of technical writing. Thus, in order to make life a little easier for all parties involved, I am going to share with you the 7 Rules that I follow when creating a piece of technical documentation. I did not think these rules up on my own. Rather, I formulated them from having had the benefit of working with many gifted technical and copy editors for more than a decade. Anything that I understand is because others have shown me the way. I cannot be more grateful.

Hopefully after reading this article, you will have some new tools in your technical writing toolbox that will help you create technical documents that are clearer, more engaging, less confusing and a lot more fun to read. Also, I’ve added at no extra charge to you, the consumer, a bonus section at the end that describes the process I use to create a piece of technical writing.

Okay, so here are the 7 Rules:

1. Dry sucks
2. Before you start, be clear about what you want your reader to do after you end
3. Write to a well formed outline, always
4. Avoid ambiguous pronouns
5. clarity = illustrations + words
6. When dealing with concepts… logical illustration and example
7. Embrace revision

1. Dry sucks

This is probably the hardest rule to formalize and the most important rule to follow. In the modern world of the Internet there are many forces at work vying for the attention of your reader. Boring, business as usual writing will not work. For better or worse, your reader wants to be entertained as well as informed. Therefore, if you create writing that is unclear and not fun, the reader will simply click the proverbial “next”; button and move on to another web page, another TV show or his or her Facebook page.

The easiest way that I’ve found to keep the reader entertained is to keep myself entertained. I make a significant effort always to write an article that I will want to read. I strive to have fun when I am writing. If I’m bored, the reader will be bored. If I’m confused, the reader will be confused. If I don’t really care about the topic at hand, the reader will never care. It’s that simple.

I like humor, so I try to make my writing humorous without compromising clarity. I try to talk to the reader, not at the reader. I write about topics that really matter to me. I use illustrations extensively in order to avoid confusing the reader.

Again, I try always to make the reading experience fun. I am aware always that I am writing in a competitive environment. There’s a lot of content out there that wants a piece of the reader’s attention. Thus, my advice for Rule #1 is, if you make your writing fun for you, it will be fun for the reader.

2. Before you start, be clear about what you want your reader to do after you end

Technical writing is all about the subsequent behavior of the reader. The reader is investing time reading your work because he or she wants to be able to do something after the reading experience is over. That something may be learning how to make chocolate chip cookies, power down a nuclear reactor or set up a Hadoop cluster. The important thing to remember is that the reader is using your writing as a means to another end. Your piece is a vehicle to another well defined behavior.

Thus, it will do you well to be very clear about what you want your reader to do after the reading experience is over. State your intention at the beginning. Don’t leave the reader guessing. Your declaration can be something as simple and obvious as, “after reading this article you will be able to [fill in the blank here].” If you are clear about what you want your reader to do after you end, the easier it will be for you to write your piece at the beginning.

3. Write to a well formed outline, always

A well formed outline is the skeleton around which your document grows. Writing a technical document without using an outline is like trying to navigate the New York City Subway System without a map. You can end up anywhere and that anywhere may not be where you intended to go.

Writing to an outline is not about creating more work. It’s about doing less work. When you write to an outline, you know where you’ve come from and where you are going to.

There are two rules of outlining that I always use.

1. A sublevel topic requires at least one peer.
2. Any outline level requires at least two sentences.

Allow me to elaborate. Listing 1 below is an example of an outline that violates the first rule: A sublevel topic requires at least one peer.

Listing 1: A poorly formed outline

1. Making an Orange Cranberry Tangerine Fizzle

1.1. The steps required for the Fizzle

1.1.1. Preparing the ingredients

1.1.2. Mixing the Fizzle

1.1.3. Serving the Fizzle

Notice please that in Listing 1, Level 1, has a single sublevel, 1.1 – The steps required for the Fizzle. This structure is a violation of the first rule. In order for a sublevel to be well formed, there must be at least one other peer for a topic. In other words, this means that there must be at least two sublevels for any given level.

Please look at Listing 2 below. Notice that there are now three sublevels to Level 1, of which the topic,Mixing the fizzle, now has peers. The single level, The steps required for the Fizzle, has been eliminated.

You may ask, “Where is the topic, The steps required for the fizzle?” The answer is that the topic is no longer an outline item but content within the parent topic as shown in Listing 2 below.

Listing 2: A well formed outline that violates the two sentence rule

1. Making an Orange Cranberry Tangerine Fizzle

The section below describes the process that you need follow to make an orange cranberry tangerine fizzle.

1.1. Preparing the ingredients

1.2. Mixing the Fizzle

1.3. Serving the fizzle

Please notice that although Listing 2 presents an outline with a properly structured sublevel, there is only a single sentence as content for the Level 1 topic. Having a single sentence only as content to an outline topic violates the second rule of outlining, Any outline level requires at least two sentences.

Listing 3 below shows the Orange Cranberry Tangerine Fizzle piece adjusted to support the Two Sentence rule.

Listing 3: A well formed outline that supports the Two Sentence Rule

1.Making an Orange Cranberry Tangerine Fizzle

An Orange Cranberry Tangerine Fizzle can be a welcome treat on a hot summer day. The beverage is made from natural ingredients with no artificial flavors. An Orange Cranberry Tangerine Fizzle not only tastes good, but it’s good for you too!

The sections below describe the process that you need follow to make an Orange Cranberry Tangerine fizzle.

1.1. Preparing the ingredients

1.2. Mixing the Fizzle

1.3. Serving the fizzle

Why all the hubbub about proper outline structure and at least two sentences to a level? First, following the Sublevel rule forces me to be very clear about the logical segmentation of my piece. Also the Sublevel rule ensures that my writing communicates my ideas with a flow that makes sense and is easy to follow.

Second, The Two Sentence rule forces me to create copy that is engaging, detailed and makes sense. “One sentence” writing often lacks detail. And, with the exception of one- liner comedy, writing of the “one sentence” variety is not the most interesting copy to read.

4. Avoid ambiguous pronouns

Ambiguous pronoun references are probably the most typical cause of confusion in the practice of technical writing.

Consider the paragraph in Listing 4.

Listing 4: A paragraph that has ambiguous pronouns

Trafalgabors are a fundamental component of the Weebietatas framework. This article shows you what they are about and how to use them.

This paragraph may seem a bit comical, but it illustrates some important points. First, the paragraph attempts to put you in a place that the reader occupies. The reader wants to understand what’s going on but is unfamiliar with the language in play. And because the language is unfamiliar, the reader is ignorant and thus, vulnerable. The reader wants new information; he or she wants to get smarter. But the reader is also a bit anxious. Admitting ignorance, even to one’s self, even at a subconscious level, can be disconcerting. The reader is cognitively fragile. Concepts and words that you, the writer, take for granted, might be completely foreign to the reader. One ill explained concept or one word used without proper clarification can turn the reader off.

In the case of the paragraph above, I would not be surprised were you to be asking, “What is a Trafalgabor? What is a Weebietata? What is the paragraph talking about? How to use Trafalgabors? How to use Weebietatas? How to use both of them? This is confusing. I am going back to my Facebook page.”

If a reader has to take time out from your writing to figure out what you are trying to communicate, not only is expository flow compromised, the reader most probably will become confused. Once you confuse the reader, you’ve lost. All the other stuff in the world demanding the reader’s attention becomes more attractive than your work. So, the “next” button is clicked and your work goes unread.

In the case of Listing 4 shown above, the confusion is caused by the ambiguous use of the pronoun,they in the second sentence. Does they refer to the Trafalgabors, the Weebietatas or both? Remember please that the reader knows nothing of Trafalgabors or Weebietatas. (Please see Figure 1 below.)

Figure 1: The use of ambiguous pronouns makes technical writing confusing

The solution to the problem is simple. Please take a look at Listing 5 below. The ambiguous pronoun is removed. Clarity is restored.

Listing 5: A remedy for ambiguous pronouuns

Trafalgabors are a fundamental component of the Weebietatas framework. This article shows you what Trafalgabors are about and how to use them

Beware! The ambiguous use of pronouns is a sign post on the road to confusing technical writing.

5. clarity = illustrations + words

Please take a look at the photo below. Tell me if you can, what is the graphic about?

Figure 1

I am not surprised should you find yourself a bit perplexed. It’s a perplexing photo. You know what the items are, but you have no idea what they mean. Such is the nature of an illustration. A picture without words lacks context.

When it comes to illustrations, readers require context in order to avoid confusion. The reader should not need to waste time or thought trying to figure out what an illustration is about. The easiest way to avoid confusing illustrations is to provide a caption.

Please take a look at the Figure 2 below. It is the same photo. There is little question as to what the photo is about.

Figure 2: The tools and ingredients required to make an Orange Cranberry Tangerine Fizzle

When it comes to technical writing, I have found it to be a good practice to provide numbered, descriptive captions with all illustrations.

Please, don’t create captions that are figure numerals only. Use both a figure numerals and a descriptive comment in the caption. Also, you’ll do well to avoid orphaning illustrations. An orphan illustration is a figure that exists within the piece of technical writing yet has no reference from within the copy.

If you insert an illustration into your writing, make sure to refer to it in your copy by figure number and location using words such as, above and below. You don’t want to reader taking time out from reading your work to try to associate an illustration to copy or to locate an illustration within your article. If you add have a “Figure 4″ in your piece, make sure that you have language in the text that says something like, please refer to Figure 4 below.

Note: The eye is attracted to pictures

A decade back I worked in the group that wrote hard copy user manuals for a very, very big computer manufacturer. All manuals were subject to formal, quantitative usability study. One of the things that the User Experience Ph. Ds taught me is that as a subject reads a manual, the reader’s eye goes to the pictures first. Then the reader will read the copy around the picture. Thus, the manual writer’s tried to make sure that every page of a manual had at least one picture.

6. When dealing with concepts… logical illustration and example, logical illustration and example

Concepts are hard to understand….that’s why they’re called, concepts. So, when it comes time for me to write about a concept, whether it is, the Second Law of Thermodynamics, a piece of coding technique or a full fledged software framework, I use the following pattern in my writing: concept – logical illustration – example. I try to never introduce a concept without substantiating the concept with a logical illustration and then an example.

Let’s apply this rule to describe an elementary algebraic concept.

The Transitive Property of Equality is as follows:

If A = B, and B = C, then A = C

Now let’s provide a logical illustration that describes the concept. (Please see Figure 3.)

Figure 3: Thee Transitive Property of Equality is a fundamental principle of elementary algebra

Listing 6 below shows a few concrete examples to solidify the understanding of the concept at hand.

Listing 6: Some concrete examples of the Transitive Property of Equality

• If 7 = 3 + 4, and 3 + 4 = 5 + 2, then 7 = 5 + 2
• If 12 + 5 = 7 + 10, and 7 + 10 = 6 + 11, then 12 + 5 = 6 + 11
• If x + y = z, and z = 2a, then x + y = 2a

Thus, the rule as has been satisfied. We presented the concept, The Transitive Property of Equality, provided a descriptive illustration and followed up with concrete examples that substantiate the concept.

Let’s move on to a concept that is more relevant to software development and a bit more difficult to understand. The concept is Maven POM Inheritance. In Exhibit 1 below you are presented with the concept at hand and then a logical illustration that describes the concept. Finally, you are presented with another illustration that shows the concrete use of a POM files in an inheritance situation.

Exhibit 1: An excerpt of technical writing that describes Maven POM Inheritance

Understanding POM File Inheritance

A POM file (Project Object Model) is the XML file that you use to describe and work with a Mavenproject. You can set up a Maven project to inherit settings from a separate parent POM file. The ability to inherit settings from a parent POM file is called, POM Inheritance. You use the <parent> element in your POM file to define a parent POM file from which to inherit settings.

Figure 4 below illustrates a fictitious project hierarchy that represents an example of how you can set up a master POM file from which other POM files can inherit common settings.

Figure 4:You can designate a master POM from which you can inherit common settings

Figure 5 below shows the contents POM.xml files for the Maven projects, stooges-web, stooges-api and stooges-dal. Each project is configured to use the <parent> element to inherit settings from stooges-project.

Figure 5: Use the <parent> element to direct a Maven project to inherit settings from an external POM file.

The example above relies heavily upon figures to provide logical illustration and a concrete example of the concept at hand. Creating interesting, engaging and accurate illustrations and examples are a difficult undertaking, but well worth the effort. Many times creating the illustrations for a piece of technical writing and providing example code will take as much, if not more time than writing the actual copy. Thus, I plan accordingly when allocating my time to meet a deadline.

When it comes to making a concept crystal clear, illustrate and then provide an example.

7. Embrace revision

It’s rare to produce a good piece of technical writing right off the bat. Understanding your topic, organizing your ideas and then finding the language to present the ideas clearly and accurately takes time as well as a lot of effort. Therefore, don’t constrain yourself by expecting to get everything right the first time. Rather, plan to write at least three versions of your piece. The first version just gets some words in print so that you can understand your intentions. The second version brings clarity and accuracy to your work. Then, once you have your facts right, your illustrations clear and your organization logical, create a third version that makes your work engaging and special.

To hijack the Thomas Edison quote, “Technical writing is 10% composition and 90% revision!”

Bonus section

Now that you learned about the 7 Rules for Creating World Class Technical Documentation, I am going to share with you the process that I use to create a piece of technical writing. It’s short, but to the point. I call the process, The 7 Steps for Making a Technical Document. Here goes:

1. I create outline, at least to the second level, hopefully to the third.
2. I add to the outline my illustration for each concept.
3. I caption my illustrations.
4. I fill in the copy to the outline, following the Two Sentence Rule, adjusting my outline to adapt to the copy at hand.
5. I revise.
6. I send the piece to a subject matter expert for review. (A subject matter expert is a person that can identify inaccuracies and unclear writing.)
7. I revise again based on the response of the reviewer(s).

There you have it. 7 Rules, 7 Steps. Who could ask for more? So, now that you’ve learned all of my tricks, feel free to go forth and make the world a more accurate, engaging, illustrative and interesting place in which to live. It’s worth the effort.

Ref: Developer.com

1. FullCalendar

FullCalendar is a famous jQuery calendar plugin which offers features like drag-and-drop, integration with Google Calendar and able to fetch events through JSON. Designers can easily customize the look and feel of the calendar, while developers can utilize the exposed hooks for user-triggered events.

2. Astonishing iCal-like Calendar

This is a tutorial which uses both jQuery and CSS to build an iPhone styled calendar application. The author also implement the Coda-like effect for the popup event.

3. jQuery UI Datepicker

The jQuery UI Datepicker is a highly configurable plugin that adds date picker functionality to your pages. You can customize the date format and language, restrict the selectable date ranges and add in buttons and other navigation options easily.

4. jMonthCalendar

jMonthCalendar supports full month calendar and events. The interesting part of this plugin is it allows developers to interact with the calendar.

5. Date Picker

Date Picker is a jQuery calendar plugin released under MIT and GPL licenses. It has a lot of options and features. For example, you can have multiple calendars in the component, mark dates as special days, easy to customize through CSS and allow different selection modes. All these can be easily setup though the configuration options.

6. jQuery Week Calendar

jQuery Week Calendar is a plugin which will include a weekly calendar in the web application. The events can be supplied as an array or JSON, and these events can be easily drag, drop and resize. There are a lot of options and event callbacks which you can refer through the official plugin page.

7. Simple jQuery Date-picker Plugin

This is a very simple date picker plugin. However, it provides a lot of useful and necessary features for a date picker. For example, you can easily navigate to the months and years through the drop down selection boxes.

8. jQuery Date Picker Plugin

This is an clean, unobtrusive plugin for jQuery which allows you to easily add date picker to your web forms and pages. There are a lot of configurations and options for this simple plugin. You can refer to the plugin page for more examples of how to use this plugin.

9. jQuery Interactive Date Range Picker

This powerful date range picker is a modified version of jQuery UI’s Datepicker component. It has a quicker date selection from a list of preset dates/ranges and a smooth transitions. The latest version uses the jQuery UI 1.7 and jQuery UI CSS Framework. With the power of jQuery UI, user can now switch the calendar theme easily.

Ref:9 Useful jQuery Calendar And Date Picker Plugins For Web Designers

The installation process for SQL Server 2008 has many different options. These options allow you more control over your SQL Server Instance configuration. Having this additional control allows you to set up your SQL Server 2008 instances out of the box with the appropriate configuration, like directory structure, accounts, etc. In this article I’ll walk you through the SQL Server installation process.

Machine Set Up

Prior to installing SQL Server 2008 you need to make sure your SQL Server machine will meet the requirements for SQL Server 2008. There are many different requirements that your SQL Server 2008 machine must meet depending on what version of SQL Server you are installing and the base operating system you are going to use. It is out of the scope of this article to describe all the different machine setups and dependences. Prior to installing SQL Server 2008 you should review the following webpage to identify the correct machine setup for your environment: http://msdn.microsoft.com/en-us/library/ms143506.aspx.

For the purpose of this article I will be installing an evaluation copy of SQL Server 2008 Enterprise Edition. The base operating system I will be installing SQL Server on will be Windows 2003 Enterprise Edition SP1 version. My machine is also configured with a C, D, E, F, and G drives. I will use these different drives to place different components of SQL Server.

Initial Setup Process

When you first stick the SQL Server 2008 CD into your drive it will automatically startup the setup process for SQL Server 2008. If the setup doesn’t start then find the “setup.exe” file and run it. When the setup process starts it will check your machine to make sure the .Net Framework and an updated copy of Windows Installer are on your machine. If these are not on your machine then setup will require that these be installed first before you can install SQL Server 2008. The setup process will walk you through installing these prerequisites if they are not already installed. If you have to install them a reboot will be required before you can perform the actual install of SQL server 2008. Once your machine has all the prerequisites installed the setup process will bring up the following window:

Click here for larger image

On this window you can see you have a number of different hyperlinks you can use. There is a navigation pane on the left that has different SQL Server 2008 items you can pick from and on the right pane are the items associated with the selected left pane item. In my case I have the “Planning” item selected. Note it is displayed in bold font. To install SQL Server 2008 I will need to click on the “Installation” item. When I do that the following screen is displayed:

Click here for larger image

On this window you can also do a number of different things related to installing SQL Server. For the purpose of this article I will be going through the first item “New SQL Server stand-alone installation or add features to an existing installation” item to create a brand new SQL Server 2008 instance.

SQL Server 2008 Installation Process

Once you click on the “New SQL Server stand-alone installation or add features to an existing installation” item a series processes will run and some dialog boxes will be displayed to allow you to configure SQL Server 2008 the way you would like. In SQL Server 2008 a number of new configuration options are available at installation time, which in prior releases had to be done after you installed SQL Server.

After the stand-alone instance installation item is click the set up process runs through a number of rule check processes to verify that your system is setup correctly. The first one does a system configuration check. After each one of these rule check processes you are given a summarized report telling you whether or not your system passed the rules checked. In that summary report you are given the option to view a detailed report of each rule. I would suggest you look at the detail rules report to verify each rule. If you find a rule that needs to be fixed you will need to resolve the issue and then re-run the rule checks.

The next window displayed is the “Product Key” window. On this window you will need to select the version you want to install and enter the product key. The list of versions displayed will depend on what media you use for the installation. Select the appropriate version and key and then click on the “Next” button. This will bring up the “License Terms” window. On this screen you should read the license terms. If you agree with the licensing terms then click on the accept checkbox followed by the “Next” button to move on with the installation. Next, you will be prompted to install the setup files. Click on the “Install” button to start the setup file installation process. Once all the setup files are installed a summary of the setup installation process will be displayed. If all the critical setup rules where meet then you will be allowed to proceed with the installation, if not you will need to fix the reported problems and re-run the setup installation. Once again this setup process has a link where you can review the details of the setup installation. I recommend you review the details prior to proceeding, so you know exactly the status of each rule installed. Once you are ready to move on with the installation click on the “Next” button. This will bring up the following window:

Click here for larger image

This window displays the different SQL Server 2008 feature you can install. Here you will click on the appropriate check boxes for the features you want to install for your instance. For the purpose of this article I’m going to only select the “Database Engine Services”, “SQL Server Books Online”, the “Management Tools – Basic”, and the “Management Tools -Complete”. Also on this screen you can select the directory where you want to install the shared features. In my case I’m installing my shared features on the “E:\” drive. Once all the features are selected and you have identified the location where you want the shared features to be installed you can then click the “Next” button to proceed. Doing that will bring up the following window:

Click here for larger image

On this window you specify whether or not you what to install a default instance or a named instance, what you want for an instance ID and the root directory of the instance. For my install I’m just going to take the defaults and install a default instance and identify that instance with an instance id ofMSSQLSERVER. But for the instance root directory I’m going to specify the “E:\”as a location. Once you are ready to move forward click on the “Next” button. The installation process will then calculate the amount of disk space required for the features you selected. The process will report the disk space requirements for each drive. Review the disk space requirements. If you realized you need to specify a different location you can use the “Back” button to go back and change installation location. once you are satisfied with the disk space allocations and placement click on the “Next” button. Doing that will bring up the following screen:

Click here for larger image

On this window you can use the “Server Accounts” tab to specify the accounts that will be used to run the different SQL Server 2008 services and use the “Collation” tab to specify the collation you would like to use. I like to use domain accounts to run my services. In my case I am just going to use the same account for all SQL Server services. So I can either enter that account multiple times next to each service or I can click on the “Use the same account for all SQL Server services” and only enter the account and password once. On this screen you can also identify the status you would like each service to be placed in at startup. Your choices are “Manual”, “Automatic” or “Disabled”. I prefer that my SQL Server Agent and SQL Server Database engine to start automatically and the SQL Server Browser service to be disabled. To set the collation for your instance use the “Collation” tab. The default collation setting is “SQL_Latin1_General_CP1_CI_AS”. I’d suggest you click on the collation tab to verify the correct collation is specified prior to proceeding. Once you are satisfied with the Server Configuration settings click on the “Next” button to proceed with the installation. Doing this will bring up the following window:

Click here for larger image

On this screen you identify database engine configuration information. There are three different tabs to accomplish this: Account Provisioning, Data Directories, and FILESTREAM. Above you can see the “Account Provisioning” configuration options. Here you can specify whether your instance is to use Windows Authentication only or you want to run in mixed mode to support SQL Server and Windows authenticated logins. If you select “Mixed Mode” then you will need to specify a password for the SA account (no more mistakes in having a blank SA account). Another change is that the “BUILTIN\Administrators” user is no longer added by default, so no more back door for member of the Administrators group. You also now have an option to add users that you want placed in the “sysadmin” built-in server role. I suggest you place at least one user in here. This will allow that user to be able to login to your instance of SQL Server 2008 after the installation is complete. You do that by adding them use the “Add” button in the screen above. You can also use the “Add Current User” button to add the user that is doing the installation to the sysadmin role.

You now have a lot more options for how you want to configure your data directories at installation time, to specify that information click on the “Data Directories” tab on the window above. Upon doing this the following window will be displayed:

Click here for larger image

As you can see here you can specify different directories for: user database DATA files, user database LOG files, tempdb DATA/LOG files, and the back up directory. This allows you to more easily separate your databases DATA and LOG files across different drives. As well allows you to make sure the system databases and tempdb files are also on different drives. Allowing you to do this now allows you to more optimally place your components at installation time to help minimize I/O bottlenecks. Here is how I configured my directories:

Click here for larger image

I have placed my user database DATA file on the E drive, where as the user LOG files are on the G drive. I also placed the tempdb DATA and LOG files on the F drive. This provided me some disk separation between components.

If you want to configure FILESTREAM during the setup process you can by using the “FILESTREAM” tab. The information under this tab allows you to specify exactly how you would like to enable and configure FILESTREAM.

Once you are happy with your Database Engine Configuration option click on the “Next” button. Doing this will bring up an “Errors and Usage Reporting” window where you can send errors and feature usage information to Microsoft. Once you have decided how to report to Microsoft there is another “Next” button to click to move on to the next step of the installation process, which is verifying all the Installation Rules. You should check this window to verify that all installation rules are successful for the components you are installing, and then click on the “Next” button. This will bring you to the final installation window. Here you get make a final review of the installation options you have selected. If there is something you want to change you can use the “Back” button to change it. once you are satisfied with the installation configuration you have identified click on the “install” button. this will start the installation process and install the components you selected in the locations you identified. once the installation process is finished the following window will be displayed:

Click here for larger image

Here you can see all the components I selected have been installed successfully. The install of my SQL Server 2008 instance with the components I selected is now done. When I click on the “Next” button here the final “Close” screen is displayed where I can click on the “Close” button to close the SQL Server 2008 setup process.

Conclusion

Now that I have walked you through the installation process you can see that there are many different options for how might want to configure SQL Server 2008. Hopefully this article has given you a sense of the different options you will need to consider in order to make sure your installation configuration goes smoothly. I suggest you do some planning up front for how best to map out each of the SQL Server components across the different disks drives you have and what account or accounts you want to use for the different SQL Server services. Doing this additional planning will help you be successful in setting up your SQL Server instance configuration the way you want it the first time you install SQL Server 2008.

Ref: Installing-SQL-Server-2008

If we want to develop a thick client application which can run on both Mac and Windows then we have the following preferred technological options.

Visual Basic:

Microsoft doesn’t provide any support for Mac compatibility. We have one 3party solution provider RealSoftware. He offer RealBasic which is similar to VB and which can be used to develop thick client applications for both Mac and Windows.

Ref: REALbasic is a rapid application development environment that enables developers to create high-quality, native software for Windows, Mac and Linux.

REALbasic includes:

• an integrated environment designed for developer productivity
• a modern, object oriented programming language
• a cross-platform object framework
• a cross compiler that produces native executables

REALbasic is used to create all types of applications, including database clients, commercial software, custom business solutions, educational products and more. In fact, REALbasic itself is written in REALbasic.

REAL Software ships updates to REALbasic every 90 days. No other software tools company ships updates at this pace.

Each new REALbasic license includes all updates for six months. When your REALbasic update plan ends you can either purchase a one year update plan renewal or continue using any release that shipped during your update plan.

http://www.realsoftware.com/support/whitepapers/portingvisualbasic/

VB.NET:

Microsoft Visual Basic .NET doesn’t have any support for Mac. There is a new technology introduced by Microsoft i.e., SilverLight which will be used to execute .NET application with out deploying the complete .NET framework at the client machine. But these applications will we based not thick clients.

SilverLight:

Microsoft® Silverlight™ is a cross-browser, cross-platform plug-in for delivering the next generation of .NET based media experiences and rich interactive applications for the Web. Silverlight offers a flexible programming model that supports AJAX, VB, C#, Python, and Ruby, and integrates with existing Web applications. Silverlight supports fast, cost-effective delivery of high-quality video to all major browsers running on the Mac OS or Windows.

Ref: http://silverlight.net/default.aspx

JAVA:

Java is an platform independent language. We an build thick client application which can be deployed on both Windows and Mac.

Ref: http://java.sun.com/developer/technicalArticles/JavaLP/JavaToMac/

There are a few companies in the market today with solutions to help serve the need for open source license identification, including Black Duck, Palamida and now OpenLogic. The business itself is also evolving from just being about detecting licenses to becoming part of an entire open source software adoption lifecycle process.

“Open source has made its way into enterprises of all sorts, and because open source software is so pervasive now, it’s critical for companies to look at how they comply with open source licenses,” Kim Weins, senior vice president of products and marketing at OpenLogic, told InternetNews.com.”Before they can comply with open source licenses, they need to know which open source licenses they are using. As much as you might think that’s easy to track, it’s not.”

OpenLogic is an open source stack and services support vendor. While it provides commercial support for open source software—most recently including the Red Hat Enterprise Linux clone, CentOS—OpenLogic’s flagship service is OpenLogic Exchange (OLEX), which enables enterprises to manage their open source usage.

This week, the company announced new OLEX services to provide license discovery and compliance.

Weins said the difficulty in license identification is that open source software is often bundled together in sophisticated ways. As a result, a single open source project can often have additionally open source projects inside of it—with bits of code inside that can all be under different licenses.

“It’s not as simple as saying this particular application is licensed under Apache and being done with it,” Weins said.

The issue has led to a number of high-profile legal spats over the last two years. For instance, the Software Freedom Law Center has settled out-of-court disputes with at least four different vendors over license violation issues that arose because of open source code buried with their software.

The business of license identification is one that Black Duck software has been involved in since 2002. For CEO Tim Yeaton, it’s a business that has evolved over the last few years to be about more than just license identification.

“We’ve expanded our capabilities from just being a compliance platform to being a full-on, open source lifecycle adoption platform,” Yeaton said. “We enable customers to search and select open source components, validate them against their process, put in workflows to automate polices, catalogue the resulting components and then attach them directly to their existing development infrastructure.”

Black Duck began its broader lifecycle adoption effort nearly two years ago with the launch of its Code Center application.

OpenLogic’s Weins said she felt her company could offer a new competitive choice by producing fewer false positives than rivals. She also added that OpenLogic’s new services are cloud-focused and leverage the power of Hadoop open source technology to deliver fast, accurate scans.

Black Duck’s Yeaton noted that his company has hosted and Software-as-a-Service offerings. He added that his concern is false negatives more so than false positives.

“If you’ve built a quality tool, done right, there is no such thing as a false positive—there are only things that you’d rather not see because they create noise,” Yeaton said, adding that scans can produce a lot of granular information that a user may not want or need.

He also said that Black Duck has filtering and automation features that lets users customize the information returned from a compliance scan, though they’re not enabled by default.

“The way we built our product and the way it’s deployed by default is that it provides access to all the information,” Yeaton said. “So shame on us for not helping customers upfront to filter. We are getting smarter to help customers to configure their systems.”

But Yeaton said the real issue for him is false negatives—that is, code that isn’t detected.

“There is clutter, because you got more information than you want, but you can turn on a filter,” he said. “But there is real corporate risk of a false negative … you don’t find something that you’re supposed to.”

By Developer.com

This article shows you how to use an <input> control to browse and upload images, and then convert those images to thumbnail versions for display on the web site. The code is straightforward without a lot of sanity checking, as is the ASPX, and works fine for example purposes, but for a production application you’ll want to add validation and error checking (but that’s another article).

Uploading Files with the <input> Element

The <input> HTML element is a versatile HTML control. Based on the value you supply for the element’s type attribute, the <input> element can function (and display) as a general-purpose button, a radio, reset, or submit button, a checkbox, a file uploader, a hidden control, an image, a password field, or a text control. For the file uploader, set the <input> element’s type attribute to file, and the <input> control displays a textbox and a button labeled “Browse.” While you can code this manually, the easiest way to display a file uploader is to select the Input (File) item from the HTML tab of Visual Studio’s Toolbox.

Figure 1. Design-Time View: From this design-time view, you can see how the sample page uses the table to lay out the other HTML elements.

The sample ASPX page contains this type of <input> element, as well as a label, a button to submit a selected image file, and an image element. The server creates a thumbnail of that image and returns it to the browser, which displays it in an <img> element on the same page. An HTML table handles the control layout (see Listing 1). At design-time, the page looks like Figure 1.

// HTML tables are pretty versatile and easy to use. If you want a simple spreadsheet-like table then use <tr> elements to add rows and <td> elements to add cells. If you want a single cell to span multiple rows then set the <td> element’s rowspan attribute, or to span multiple columns, set its colspan attribute.

The only other interesting aspect of the HTML in Listing 1 is that the <img> control (in column 2 in Figure 1) has an ID attribute, and its runat attribute is set to server. Setting the runat attribute lets you manipulate the <img> control in the server-side code behind. You’ll use this to display the created thumbnail image.

Saving the Uploaded Image

When an <input> control has its type attribute set to file, a user can click the Browse button to select a file. After selecting a file, when the user submits the page the <input> control will have a populated PostedFile property, which is a class that will contain the file’s contents and other file information, such as its file name. To be specific, PostedFile is an instance of the HttpPostedFile class.

To use the GUI, a user clicks the Browse button, selects a file, and then clicks the Upload button. On the server, you can save the posted file by calling the <input> control’s PostedFile.SaveAs method, passing the path and file name where you want to save the file. The following code shows just how easy this part of the process is:

Private Const imagePath As String = “~/Images/”

Private Sub SaveUploadedFile(ByVal filename As String)

File1.PostedFile.SaveAs(MapPath(imagePath) + filename)

End Sub

In the preceding code, File1 is the ID of the <input> control. (The <input> control has the runat=”server” attribute set, so even though it’s an HTML control, it is available on the server side too.)

Creating and Display the Thumbnail

The sample program uses a Button control to submit the default form containing the <input> element. The <input> element has the posted file. The complete code, shown in Listing 2, performs four steps:

1. Extract the file name from the posted file path
2. Save the uploaded file to a pre-determined server path
3. Save a thumbnail copy of the image
4. Set the <img> element’s src attribute to the thumbnail’s location

When the user submits the file, File1.PostedFile.FileName contains the client’s local path (the location of the file on the user’s machine). You will want to extract the filename without the path, which you can do with the System.IO.Path class’s GetFileName method.

The SaveUploadedFile method shown earlier uses the PostedFile.SaveAs method to save the file. Note that it uses the MapPath method, which maps a server-side relative path to its physical path. It appends the file name to that path, which creates a complete pathname where it saves the uploaded file. (You could also save the file to a database or display the file contents on the web page.)

The next step is to create the thumbnail image. The SaveThumbnail method creates a thumbnail copy of the image.

Private Sub SaveThumbnail(ByVal filename As String)

Dim image As Image = image.FromStream( _

File1.PostedFile.InputStream)

Dim thumbnail As Image = image.GetThumbnailImage( _

100, 100, AddressOf Callback, IntPtr.Zero)

thumbnail.Save(MapPath(GetThumbnailPath(filename)))

End Sub

Private Function GetThumbnailPath( _

ByVal filename As String) As String

Return “~/Images/” + _

String.Format(thumbnailMask, filename)

End Function

The SaveThumbnail method creates an in-memory System.Drawing.Image instance from the HttpPostedFile’s InputStream property by passing the input stream to the Image.FromStream method. Next, it creates a thumbnail copy of the image by calling the Image’s GetThumbnailImage method. GetThumbnailImage has some odd arguments, mostly because its implementation calls into unmanaged code. The first two arguments are the width and height of the thumbnail image, the third argument is an unused callback delegate, which you must provide, even though it’s unused. The fourth argument is another unused relic to satisfy the native code call. The final argument must be IntPtr.Zero. (Obviously, a better thumbnail wrapper probably needs to be created.) Finally, the method saves the thumbnail in the same location as the original image, but with the prefix thumbnail_ added to the file name.

Finally, the SetPreviewImage uses the virtual path for the thumbnail and assigns it to the <img> element’s src property.

Private Sub SetPreviewImage(ByVal filename As String)

PreviewImage.Src = GetThumbnailPath(filename)

End Sub

The topic of uploading files is a bit of an oldie, but it is still a goody. Creating and showing thumbnails is a good way to let users preview numerous images, and then select a full-sized version. The GetThumbnailImage method makes a call into unmanaged native code, so it has some unused “junk” arguments that make it a little cumbersome to use—but now you have the CliffNotes.

Uploading an Image and Creating a Thumbnail in ASP.NET

This article will show you how to define both a custom skin and a theme for a web application.

Adding a Theme to Your Web Application

You can add a custom theme to your web project from the Solution Explorer. Right-click the root project name and click “Add ASP.NET Folder” from the context menu, and then select the Theme item. This step adds an App_Themes folder containing a Theme1 subfolder. The intent is that each theme subfolder should contain all the elements for a particular theme. Therefore, if you want to have multiple themes, simply add additional Theme sub-folders to the App_Themes folder.

App_Themes

Defining a Skin File

Skin files are XML files with a .skin extension. To add a skin file to your web project’s Theme folder, right-click the Theme folder (Theme1 in this example), and select Add New Item. From the Add New Item dialog select the Skin File item.

Visual Studio inserts a skin file template that initially contains a comment and some boilerplate heading information that shows you two examples:

<%--
Default skin template. The following skins are provided as examples only.
1. Named control skin. The SkinId should be uniquely defined because
   duplicate SkinId's per control type are not allowed in the same theme.
<asp:GridView runat="server" SkinId="gridviewSkin" BackColor="White" >
   <AlternatingRowStyle BackColor="Blue" />
</asp:GridView>
2. Default skin. The SkinId is not defined. Only one default
   control skin per control type is allowed in the same theme.
<asp:Image runat="server" ImageUrl="~/images/image1.jpg" />
--%>

Figure 1. Associating Controls with Skins: If your skin files contain control properties with a SkinId attribute set, then you can select a specific value for the control’s SkinID property.

The first example in the preceding skin file contains a SkinId, while the second example does not. That’s important, because when a skin element has a SkinId it belongs to the group of items having that same SkinId. However, elements without a SkinId become part of the default Skin definition.

A skin file can contain multiple skins. You can have one default skin—control properties without a SkinId—and as many named skins as you want: control properties with SkinId attributes. If your skin elements have a SkinId then Visual Studio will let you select the various SkinId values from a control’s SkinID property (see Figure 1).

One reasonable way to define control properties for a skin file is to format the item’s appearance directly in an ASP.NET web page—and then copy and paste the applicable elements from the ASPX file to the .skin file. The following code shows the skin file elements defined for the example application:

<asp:GridView runat="server"
  AllowPaging="true" Font-Names="Tahoma"
  Font-Size="9pt" CellPadding="4">
  <HeaderStyle BackColor="#C1DBFA" />
  <AlternatingRowStyle BackColor="#ECF4FE" />
  <RowStyle />
  <PagerStyle CssClass="PagerStyleClass" BackColor="#C1DBFA" />
</asp:GridView>

Figure 2. Skinned GridView: Here’s how the GridView looks with a skin file applied.

Notice that the boilerplate comments were removed from the preceding code, which provides HeaderStyle, AlternatingRowStyle, and PagerStyle settings. The skin contents also look very similar to the HTML/XML that defines a GridView in an ASPX page.

These control properties define a default skin. The skin specifies BackColor attributes for the header and alternating rows, and references a cascading style sheet class for the PagerStyle (discussed in more detail in the next section). It’s worth noting that the runat attribute has to be set to server in the .skin file. Figure 2 shows the result when this skin file is applied to a GridView.

Building Out a Cascading Style Sheet

While writing my latest book, I got so used to looking at the Aqua theme provided with the DevExpress controls that I decided to approximate it for the demo. The style employs a subtle contrast between the header and footer and the alternating rows. The preceding skin file defines the control properties, including fonts and colors; however, skin files do not support style information for HTML elements. You need to define those in a cascading style sheet. The good news is that adding a cascading style sheet to your theme automatically incorporates it as part of the theme, without you having to add a specific reference in your web page.

The example in Figure 2 shows a GridView populated with information from the Northwind database’s Customers table. The grid is inside a <div> tag with some padding applied, and the table header <th> and table cell <td> use a solid thin blue border. (Remember that controls such as GridViews are rendered as HTML.) The pager is also rendered as an HTML table, but I didn’t want a border around the pager items. To eliminate the border around the pager items the PagerStyleClass uses a combinatory * and td to indicate that descendant td elements inside of the PagerStyleClass will use the PagerStyleClass settings. Here’s the CSS file added to Theme1:

body {
}
.divClass
{
  border:solid thin Silver;
  margin: 10px 20px 10px 20px;
  padding: 10px 20px 10px 20px;
}
.PagerStyleClass * td
{
  border-style: none;
}
th, td
{
  border:solid thin #A3C0E8;
}

The .divClass entry defines a border, margin, and padding. This .divClass is assigned to the page’s main <div> tag’s class attribute. The element styles for the th (table header) and td (table cell) define a solid, thin, bluish border. All <th> and <td> elements will employ this style unless it’s overridden by some other style. You could also define a specific style class for the grid using the combinator approach used with the .PagerStyleClass. Finally, the .PagerStyleClass * td uses the combinator * to mean that the style information applies to descendant table cells.

With the theme complete, you can remove all redundant control properties from the ASPX pages to unclutter the ASPX code. You don’t have to do this because theme information overrides local property settings—but doing so may eliminate some confusion. Here’s the ASPX code for the sample solution:

<%@ Page Language="VB" AutoEventWireup="false"
  CodeFile="Default.aspx.vb" Inherits="_Default" %>

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN"
  "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">

<html xmlns="http://www.w3.org/1999/xhtml">
<head runat="server">
    <title></title>
</head>
<body>
    <form id="form1" runat="server">
    <div>
      <asp:GridView ID="GridView1" runat="server" AutoGenerateColumns="False"
        DataKeyNames="CustomerID" DataSourceID="SqlDataSource1">

        <Columns>
          <asp:BoundField DataField="CustomerID" HeaderText="CustomerID" ReadOnly="True"
            SortExpression="CustomerID" />
          <asp:BoundField DataField="CompanyName" HeaderText="CompanyName"
            SortExpression="CompanyName" />
          <asp:BoundField DataField="ContactName" HeaderText="ContactName"
            SortExpression="ContactName" />
          <asp:BoundField DataField="ContactTitle" HeaderText="ContactTitle"
            SortExpression="ContactTitle" />
          <asp:BoundField DataField="Address" HeaderText="Address"
            SortExpression="Address" />
          <asp:BoundField DataField="City" HeaderText="City" SortExpression="City" />
          <asp:BoundField DataField="Region" HeaderText="Region"
            SortExpression="Region" />
          <asp:BoundField DataField="PostalCode" HeaderText="PostalCode"
            SortExpression="PostalCode" />
          <asp:BoundField DataField="Country" HeaderText="Country"
            SortExpression="Country" />
          <asp:BoundField DataField="Phone" HeaderText="Phone" SortExpression="Phone" />
          <asp:BoundField DataField="Fax" HeaderText="Fax" SortExpression="Fax" />
        </Columns>
        <PagerStyle BorderStyle="None" />
      </asp:GridView>
      <asp:SqlDataSource ID="SqlDataSource1" runat="server"
        ConnectionString="<%$ ConnectionStrings:NorthwindConnectionString %>"
        SelectCommand="SELECT * FROM [Customers]"></asp:SqlDataSource>
    </div>
    </form>
</body>
</html>

Adding the Theme to a Web Page

You can apply a theme to an individual web page by adding either a Theme or a StyleSheetTheme attribute to the page’s @Page directive. The following code fragment demonstrates how to use the Theme attribute; you use the StyleSheetTheme attribute in the same way:

<%@ Page Language="VB" AutoEventWireup="false"
  CodeFile="Default.aspx.vb" Inherits="_Default" Theme="Theme1"%>

Adding a Theme to an Entire Web Application

If you want to apply a theme to your entire web application, then you set the theme attribute of the <pages> tag in the web.config file as shown below:

<pages theme="Theme1">

You’ve seen the rudiments of custom themes, skin files, and cascading style sheets, including the subtle yet important difference between the @Page Theme and @Page StylesheetTheme attributes. For some great ideas for defining custom themes, look at some of the pre-defined themes used for other sample projects and existing web sites. You can also check out DevExpress’s ASP.NET controls for good theme ideas. You can download trial versions at http://www.devexpress.com.

About the Author

Paul Kimmel is the VB Today columnist for www.codeguru.com. He has written several books on object-oriented programming and .NET. Check out his latest book Professional DevExpress ASP.NET Controls (from Wiley), and watch for his upcoming book Teach Yourself the ADO.NET Entity Framework in 24 Hours (from Sams). Paul is also a Technical Evangelist for Developer Express, Inc. You can ask him about Developer Express or read his DX blog here.

Ref: Implementing Skins and Themes for ASP.NET

Let’s start by looking at the code in its entirety; the people that just want to grab the code and use it can do so. I will then explain the code.

PLAIN TEXT

C#:

1. // CREATE EMAIL
2. // first we create a plain text version and set it to the AlternateView
3. // then we create the HTML version
4. MailMessage msg = new MailMessage();
6. msg.From = new MailAddress(TextBoxYourEmail.Text);
7. msg.Subject = “Event: ” + labelEventName.Text;
8. msg.To.Add(TextBoxEmail1.Text);
10. // create a string to hold all email addresses
11. StringBuilder sbEmailTo = new StringBuilder();
12. sbEmailTo.Append(TextBoxEmail1.Text);
14. if (!String.IsNullOrEmpty(TextBoxEmail2.Text)) { msg.To.Add(TextBoxEmail2.Text); sbEmailTo.Append(“, ” + TextBoxEmail2.Text); }
15. if (!String.IsNullOrEmpty(TextBoxEmail3.Text)) { msg.To.Add(TextBoxEmail3.Text); sbEmailTo.Append(“, ” + TextBoxEmail3.Text); }
16. if (!String.IsNullOrEmpty(TextBoxEmail4.Text)) { msg.To.Add(TextBoxEmail4.Text); sbEmailTo.Append(“, ” + TextBoxEmail4.Text); }
17. if (!String.IsNullOrEmpty(TextBoxEmail5.Text)) { msg.To.Add(TextBoxEmail5.Text); sbEmailTo.Append(“, ” + TextBoxEmail5.Text); }
19. String plainEmail = TextBoxYourName.Text + ” has invited you to an event! \r\n \r\n” +
20. “Event Name: ” + labelEventName.Text + “\n” +
21. “Event Date: ” + eventTextBox.Text + “\n” +
22. “Event Description: ” + labelEventDescription.Text + “\r\n \r\n” +
23. “Message: ” + TextBoxPersonalMessage.Text;
25. //first we create the Plain Text part
26. AlternateView plainView = AlternateView.CreateAlternateViewFromString(plainEmail, null, “text/plain”);
27. msg.AlternateViews.Add(plainView);
29. //now create the HTML version
30. MailDefinition message = new MailDefinition();
31. message.BodyFileName = “email.htm”;
32. message.IsBodyHtml = true;
33. message.From = TextBoxYourEmail.Text;
34. message.Subject = “Zoo Event: ” + labelEventName.Text;
36. //embed images for the email
37. EmbeddedMailObject emo = new EmbeddedMailObject();
38. emo.Path = @”~\Images\email\hdr_roar.gif”;
39. emo.Name = “hdr”;
41. EmbeddedMailObject emo2 = new EmbeddedMailObject();
42. emo2.Path = @”~\Images\email\box_top.gif”;
43. emo2.Name = “box_top”;
45. message.EmbeddedObjects.Add(emo);
46. message.EmbeddedObjects.Add(emo2);
48. //Build replacement collection to replace fields in email.htm file
49. ListDictionary replacements = new ListDictionary();
50. replacements.Add(“<%EVENTDATE%>”, eventTextBox.Text);
51. replacements.Add(“<%EVENTNAME%>”, labelEventName.Text);
52. replacements.Add(“<%FROMNAME%>”, TextBoxYourName.Text);
53. replacements.Add(“<%EVENTDESCRIPTION%>”, labelEventDescription.Text);
54. replacements.Add(“<%PERSONALMESSAGE%>”, TextBoxPersonalMessage.Text);
56. //now create mail message using the mail definition object
57. //the CreateMailMessage object takes a source control object as the last parameter,
58. //if the object you are working with is webcontrol then you can just pass “this”,
59. //otherwise create a dummy control as below.
60. MailMessage msgHtml = message.CreateMailMessage(sbEmailTo.ToString(), replacements, new LiteralControl());
62. AlternateView htmlView = AlternateView.CreateAlternateViewFromString(msgHtml.Body, null, “text/html”);
63. msg.AlternateViews.Add(htmlView);
65. // send email now (check web.config)
66. SmtpClient smtp = new SmtpClient();
67. smtp.Send(msg);

The Setup

Add the System.Net.Mail namespace. The System.Net.Mail namespace contains everything we need to send email using a Simple Mail Transfer Protocol (SMTP) server for delivery.

Modify the Web.config file to include the below:

PLAIN TEXT

CODE:

1. <system.net>
2. <mailSettings>
3. <smtp from=”admin@company.com”>
4. <network host=”localhost” port=”25″  />
5. </smtp>
6. </mailSettings>
7. </system.net>

The kicker and not well documented part to note is the from=”admin@company.com” in the smtp tag. You can change the from address later, but the MailDefinition class needs this here.

That’s it for setup. Now let’s look at the first chunk of code.

Create The Plain Text Version

PLAIN TEXT

C#:

1. MailMessage msg = new MailMessage();

The MailMessage class represents an email message that can be sent using the SmtpClient class.

PLAIN TEXT

C#:

1. msg.From = new MailAddress(TextBoxYourEmail.Text);
2. msg.Subject = “Event: ” + labelEventName.Text;
3. msg.To.Add(TextBoxEmail1.Text);

Pretty straight-forward. This just assigns the From, Subject and To properties to our mail message.

PLAIN TEXT

C#:

1. // create a string to hold all email addresses
2. StringBuilder sbEmailTo = new StringBuilder();
3. sbEmailTo.Append(TextBoxEmail1.Text);
5. if (!String.IsNullOrEmpty(TextBoxEmail2.Text)) { msg.To.Add(TextBoxEmail2.Text); sbEmailTo.Append(“, ” + TextBoxEmail2.Text); }
6. if (!String.IsNullOrEmpty(TextBoxEmail3.Text)) { msg.To.Add(TextBoxEmail3.Text); sbEmailTo.Append(“, ” + TextBoxEmail3.Text); }
7. if (!String.IsNullOrEmpty(TextBoxEmail4.Text)) { msg.To.Add(TextBoxEmail4.Text); sbEmailTo.Append(“, ” + TextBoxEmail4.Text); }
8. if (!String.IsNullOrEmpty(TextBoxEmail5.Text)) { msg.To.Add(TextBoxEmail5.Text); sbEmailTo.Append(“, ” + TextBoxEmail5.Text); }

In this example they have the option of sending the email to more than one recipient. So we perform a check on the four optional text-boxes to see if they have email addresses and if they are not empty then we add them to our MailMessage instance. In addition, we append them to our StringBuilder instance which we will end up using later.

PLAIN TEXT

C#:

1. String plainEmail = TextBoxYourName.Text + ” has invited you to an event! \r\n \r\n” +
2. “Event Name: ” + labelEventName.Text + “\n” +
3. “Event Date: ” + eventTextBox.Text + “\n” +
4. “Event Description: ” + labelEventDescription.Text + “\r\n \r\n” +
5. “Message: ” + TextBoxPersonalMessage.Text;
7. //first we create the Plain Text part
8. AlternateView plainView = AlternateView.CreateAlternateViewFromString(plainEmail, null, “text/plain”);
9. msg.AlternateViews.Add(plainView);

Here we simply create a string which we’ll use as our plain-text email message. But remember, we only want to use the plain-text version of the email if their mail client does not support HTML. Therefore we use the AlternateView class and add it to our MailMessage instance. We could have chosen not to use the alternate view and just made it the body of our MailMessage instance, but not this time.

That’s it for the plain-text version, now we will handle the HTML version.

Create The HTML Version

PLAIN TEXT

C#:

1. //now create the HTML version
2. MailDefinition message = new MailDefinition();
3. message.BodyFileName = “email.htm”;
4. message.IsBodyHtml = true;
5. message.From = TextBoxYourEmail.Text;
6. message.Subject = “Zoo Event: ” + labelEventName.Text;

Notice we use the MailDefinition class this time and not the MailMessage class as we did with the plain-text version. That’s because it’s the MailDefinition class that allows us to to create an email from an HTML file. Notice the BodyFileName property that we have set to our “email.htm” file. This is just a regular old HTML file. Lastly, we set the IsBodyHtml property to true.

PLAIN TEXT

C#:

1. //embed images for the email
2. EmbeddedMailObject emo = new EmbeddedMailObject();
3. emo.Path = @”~\Images\email\hdr_roar.gif”;
4. emo.Name = “hdr”;
6. EmbeddedMailObject emo2 = new EmbeddedMailObject();
7. emo2.Path = @”~\Images\email\box_top.gif”;
8. emo2.Name = “box_top”;
10. message.EmbeddedObjects.Add(emo);
11. message.EmbeddedObjects.Add(emo2);

The above code adds two images to the HTML file. The EmbeddedMailObject represents an item to embed in a mail message. Notice the Name property. This is important because in our HTML file (email.htm) we have this <img src=”cid:hdr” alt=”" /> code which is where it maps to the image. This way of adding images to our MailDefinition object will send the images with the email. If you don’t wish to send images with your email you may choose to simply add absolute paths to your images in your HTML file like normal. Just make sure the paths are absolute.

PLAIN TEXT

C#:

1. //Build replacement collection to replace fields in email.htm file
2. ListDictionary replacements = new ListDictionary();
3. replacements.Add(“<%EVENTDATE%>”, eventTextBox.Text);
4. replacements.Add(“<%EVENTNAME%>”, labelEventName.Text);
5. replacements.Add(“<%FROMNAME%>”, TextBoxYourName.Text);
6. replacements.Add(“<%EVENTDESCRIPTION%>”, labelEventDescription.Text);
7. replacements.Add(“<%PERSONALMESSAGE%>”, TextBoxPersonalMessage.Text);

This is an important part. This is where we pass in fields to our HTML template. Within our HTML file we find this <%EVENTDATE%> . This is a placeholder that we use to pass in content. Pretty cool eh? Almost like a mail-merge in Word. So all the above gets mapped into our HTML template. Now we see the power of this solution. It sure beats creating a huge string. We have a regular old HTML file with the placeholders that we pass in the content. Any future changes can be done right in the HTML file. Nice…

Now the last code section:

PLAIN TEXT

C#:

1. //now create mail message using the mail definition object
2. //the CreateMailMessage object takes a source control object as the last parameter,
3. //if the object you are working with is webcontrol then you can just pass “this”,
4. //otherwise create a dummy control as below.
5. MailMessage msgHtml = message.CreateMailMessage(sbEmailTo.ToString(), replacements, new LiteralControl());
7. AlternateView htmlView = AlternateView.CreateAlternateViewFromString(msgHtml.Body, null, “text/html”);
8. msg.AlternateViews.Add(htmlView);
10. // send email now (check web.config)
11. SmtpClient smtp = new SmtpClient();
12. smtp.Send(msg);

The CreateMailMessage method creates the email message and does the merging of our replacement list with the placeholders. We also pass in the string that we created earlier. Remember the string held all the email recipient addresses. The last parameter is looking for a control that owns the MailDefinition. We don’t have one so we just pass in a dummy control.

All that remains is to send the email message via the smtp protocol. If everything in your Web.config file is set up correctly your email should be on the way.