Coding Vortex

SQL 70-461 - Query SQL Server 2012 Study guide

2012-04-04T13:44:00.002-07:00

I am currently preparing for the upcoming SQL 2012 exam 70-461. Since no book currently is available my best resource and always is the best resource is the MSDN. So here is what I have as far as the outline and it's corresponding entries in the MSDN and other sources. I will continue to update over the next few days.

Create Database Objects (24%)

Create and alter tables using T-SQL syntax (simple statements).
- ALTER
- DROP
- ALTER COLUMN
- CREATE
Create and alter views (simple statements).
Design views.
- View Summary
- ensure code non regression by keeping consistent signature for procedure, views, and function (interfaces)
- security implications
Create and modify constraints (simple statements).
- Create constraints on tables
- define constraints
- unique constraints
- default constraints
- primary and foreign key constraints
Create and alter DML triggers.
- Create Trigger
- Alter Trigger
- inserted and deleted tables
- Nested Triggers
- Types of Triggers
- Update Functions
- Handle multiple rows in a session
- performance implications of triggers

Work with Data (27%)

Query data by using SELECT statements.
- Ranking Function
- write and perform queries efficiently using the new code items such as synonyms and joins (except, intersect)
- implement logic which uses dynamic SQL and system metadata
- write efficient, technically complex SQL queries, including all types of joins versus the use of derived tables
- determine what code may or may not execute based on the tables provided
- given a table with constraints, determine which statement set would load a table use and understand different
- data access technologies
- CASE versus ISNULL versus COALESCE
Implement sub-queries.
- identify problematic elements in query plans
- Pivot and Unpivot</>
- Apply Operator
- CTE Statement
- With Statement
Implement data types.
- use appropriate data
- understand the uses and limitations of each data type
- Impact of GUID (newid, newsequentialid) on database performance, when to use which data type for columns
  Article 1
  Article 2
  Unique Identifier
  NEWID
  NEWSEQUENTIALID
Implement aggregate queries.
- Analytic functions
  - CUME_DIST
  - FIRST_VALUE
  - LAG
  - LAST_VALUE
  - LEAD
  - PERCENTILE_CONT
  - PERCENTILE_DISC
  - PERCENT_RANK
- Grouping sets
- Spatial Aggregates
  Summary
  - Collection
  - ConvexHull
  - Envelope
  - Union
- Apply ranking functions
Query and manage XML data.

Modify Data (24%)

Create and alter stored procedures (simple statements).
Modify data by using INSERT, UPDATE, and DELETE statements.
Combine datasets.
- SQL Joins
- Join Fundamentals
- Union
- Case vs. Isnull vs. Coalesce
- Merge
Work with functions.

Troubleshoot and Optimize Queries (25%)

Optimize queries.
- Understand statistics
- Read query plans
- DMVs
- Hints
- Statistics IO
- Dynamic vs. Parameterized queries
- describe the different join types (HASH, MERGE, LOOP) and describe the scenarios in which they would be used
  - Fundamentals
  - INNER
  - OUTER
  - CROSS
  - SELF
  - Join Hints
    - HASH
    - MERGE
    - LOOP
Manage transactions.
- Transactions
- Understand begin, commit, and rollback
  - BEGIN
  - COMMIT
  - ROLLBACK
- Implicit vs. explicit transactions
- Isolation levels scope and type of locks
- Trancount
Evaluate the use of row-based operations vs. set-based operations.
- Use set based rather than row based logic
- When to use cursors
- Impact of scalar UDFs
- Combine multiple DML operations - Just use merge
Implement error handling.

CSSLP Study Guide Section I

2011-08-04T11:38:00.000-07:00

This is my current Study Guide for the CSSLP that I plan to take soon. Most link currently go to Wikipedia, and as I find better sources I will update.

Secure Software Concepts

Confidentiality, Integrity, Availability
Authentication, Authorization, and Auditing
Security Design Principles
Risk Management
Regulations, Privacy, and Compliance

Software Architecture

Secure Software Development Methodologies

Legal
- Copyright
- IP
- Trademark
Standards
- ISO 2700x
- OWASP
Security Models
Trusted Computing
Acquisition
- Contracts
- SLAs
- Specifications

XNA Tutorial Series 1: Golf (Patience) Solitaire Part III - Deck Class

2011-07-20T05:40:00.000-07:00

 Golf Solitaire as described by wikipedia:

Golf is a Patience game where players try to earn the lowest number of points (as in golf, the sport) over the course of nine deals (or "holes" to further use golfing teminology). It has a tableau of 35 face-up cards and a higher ratio of skill to luck than most other solitaire card games.

My attempts in this tutorial series will be able to keep the code reusable and hopefully build onto this series with other Card/Solitaire games.

XNA Tutorial Series 1: Golf (Patience) Solitaire Part III - Deck Class
For this tutorial we will focus on the class that will handle the logic for a group of cards. Start by right clicking on your classes folder and adding a new class called Deck.cs. The first thing we will need to do is setup are using's as follows:

using System;
using System.Collections.Generic;
using System.Linq;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Content;
using Microsoft.Xna.Framework.Graphics;
using Microsoft.Xna.Framework.Input;

Next set your class to be public.

Now we can begin by adding a Enum to our class to represent a deck type:

public enum DeckType
{
User = 1,
Source,
Waste,
Target
};

Now we can setup the individual properties that a Card will have, I will show the code first and then proceed to explain what each property is for:

protected List cards = new List();
protected Point pos;
protected int deckID;
protected DeckType deckType;
Texture2D background;

public virtual Point Position
{
get
{
return pos;
}
set
{
pos = value;
}
}

public DeckType Type
{
get
{
return deckType;
}
}

cards will be a list of the cards in the deck, pos is a point that is used for offsetting a card image so you can have one card on top of another and see the values for both. deckID is an ID for keeping track of the decks. DeckType to indicate the enum for which type of deck it is, and a texture to store the decks background.

Next we have our constructors:

public Deck()
{
deckType = DeckType.User;
}

public Deck(int id)
{
deckID = id;
deckType = DeckType.User;
}

Since this deck class is going to be a base type it will default to being a user deck, other deck types (waste, source, etc..) will implement the desk class. Next we will need some basic methods for maintaining the list of cards that are in the deck.

First we will need to be able to retrieve the number of cards in the deck:

public virtual int CardCount()
{
return cards.Count();
}

Get the last card(top) of the deck
public virtual Card GetLast()
{
return cards.Last();
}

Remove the last card
public virtual Card RemoveLast()
{
Card card = cards.Last();
cards.Remove(card);
return card;
}

And finally get a card
public virtual Card GetCard(int index)
{
return cards[index];
}

In the second part of the deck class we will look at Adding cards, handling input, and drawing the cards.

XNA tutorial

2011-07-19T06:23:00.001-07:00

I have been a little busy lately with studying for the CSSLP, but the next tutorial in the XNA Solitaire series will be coming soon.

XNA Tutorial Series 1: Golf (Patience) Solitaire Part II - Card Class

2011-07-11T11:02:00.000-07:00

 Golf Solitaire as described by wikipedia:

using System;

using Microsoft.Xna.Framework;

using Microsoft.Xna.Framework.Content;

using Microsoft.Xna.Framework.Graphics;

using Microsoft.Xna.Framework.Input;

Next set your class to be public.

Now we can begin by adding some Enums to our class. The first enum will deal with the suit of the cards:

public enum CardSuit
{
Clubs = 1,
Diamonds,
Hearts,
Spades
}

The next enum will be for the value of the cards:

public enum CardValue

{

Ace = 1,

Two,

Three,

Four,

Five,

Six,

Seven,

Eight,

Nine,

Ten,

Jack,

Queen,

King

}

The final enum will be for indicating what color the card is:

public enum CardColor
{
Black = 1,
Red
}

Now we can setup the individual properties that a Card will have, I will show the code first and then proceed to explain what each property is for:

public CardSuit Suit { get; set; }
public CardValue Value { get; set; }
public CardColor TheColor { get; set; }
public Boolean IsTurned { get; set; }
public Card ParentCard { get; set; }
public Card ChildCard { get; set; }
public int ZOrder { get; set; }
public String CardName { get; set; }
public Deck OwnerDeck { get; set; }
public Rectangle OriginRect { get; set; }
public static int CARD_WIDTH = 80;
public static int CARD_HEIGHT = 110;
Texture2D card = null;
Texture2D cardBack = null;
Rectangle rect;

public Rectangle CardRectangle
{
get
{
return rect;
}
set
{
rect = value;
}
}

The first three will be used to set the enums(Suit, value, and color) for the specific card. IsTurned will be used to determine if the front or the back of the card should be drawn. ParentCard and ChildCard will be used for indicating what card is above and below the card on the screen. ZOrder is similar to the css property z-index and will be used for card drag and drop. Though this game does not have drag and drop capability we are adding the ZOrder property for future use. CardName will be a string that will indicate which artwork to use, it will be made up of concatenating the cards suit with a "-" and the cards value. If you choose to use cards other than the ones I provide, please be sure they follow this naming convention. OwnerDeck will refer to which deck the card is currently in (draw pile, plateau, waste, etc...) this refers to a class that we will develop in part 3 of this series. Teh we have the OriginRect this is a placeholder value so that we always know where the card came from, in case we ever need to return it to that spot. Then we have two static variables for storing the size of the card. Next we have two XNA textures that will store the card image and the back of the card image. Finally we have the rectangle where those card images will be drawn.

Next up is the constructor followed by a description:

public Card(CardSuit suit, CardValue value, int z, ContentManager contentManager)
{
ZOrder = z;
ParentCard = null;
ChildCard = null;
OwnerDeck = null;

LoadCard(suit, value, contentManager);
}
Since we are just declaring the card and not yet putting it in a deck we will be setting several of the properties to null, and then lastly we call another method to load the cards content based on the suit and value that we passed in.

The cards Load method is detailed next:

public void LoadCard(CardSuit suit, CardValue value, ContentManager contentManager)
{
if (suit == CardSuit.Clubs || suit == CardSuit.Spades)
TheColor = CardColor.Black;
else
TheColor = CardColor.Red;

Suit = suit;
Value = value;

//Set default pos and size
CardRectangle = new Rectangle(0, 0, CARD_WIDTH, CARD_HEIGHT);

// Card background
cardBack = contentManager.Load("Cards/card_background");

CardName = suit.ToString() + "_" + value.ToString();

card = contentManager.Load("Cards/" + CardName);
}
Based on the suit we first determine the cards color, Clubs/Spades are black and Hearts/Diamonds are red. We set the cards suit and value from the passed in parameters and then we create the rectangle that will hold the card texture. Next we load the cards background picture into its texture, and then after determine the cards name we load the card image into its texture.

Finally we have the method that will draw the card to the screen:

public void Draw(SpriteBatch theSpriteBatch)
{
if (IsTurned)
{
if (card != null)
theSpriteBatch.Draw(card, CardRectangle, Color.White);
}
else
{
if (cardBack != null)
theSpriteBatch.Draw(cardBack, CardRectangle, Color.White);
}
}
Here we are determining if the card is face up or face down and drawing that particular image to the screen.

That is it right now for our card class. In the future it will be expanded more to handle different input types like drag and drop but for now clicking on the card is all that is necessary. Also not the reason the card has no coordinates is because it's draw location will be based on the location of it's stack/deck. Stay tuned for the next part in the series where we will make a deck class.

XNA Tutorial Series 1: Golf (Patience) Solitaire Part I - Project Setup

2011-07-11T10:07:00.000-07:00

Golf Solitaire as described by wikipedia:
Golf is a Patience game where players try to earn the lowest number of points (as in golf, the sport) over the course of nine deals (or "holes" to further use golfing teminology). It has a tableau of 35 face-up cards and a higher ratio of skill to luck than most other solitaire card games.

My attempts in this tutorial series will be able to keep the code reusable and hopefully build onto this series with other Card/Solitaire games.

XNA Tutorial Series 1: Golf (Patience) Solitaire Part I - Project Setup

Start by creating a new XNA 4.0 Windows game project. In my sample I named the project "Patience" but you are free to name it whatever you like. Then in the main project right click the project and add a new folder called classes. This will be where we define our game logic.

Also in your Content Project right click and add "Cards" and "Fonts" Directories. Where the actual game art will be stored. Right now that gives us the basis for starting our game. In the next tutorial we will focus on creating the Card class.

XNA Tutorials

2011-07-07T08:32:00.001-07:00

I will begin an XNA tutorial series here soon!!!

Webdesign tips

2010-02-13T12:12:00.000-08:00

My web host just published some good web design tips & tricks that I thought i would share, you can find them here: http://cncwebsolutions.com/web-design-tips.html

8 Tips for Designing a Great Website

1. Select a color scheme and stick to it.

If your company has a logo or preferred colours on its stationery that’s a good start. For those of you starting from scratch, choose two or three complementary colours and stick with them – don’t change colours on every page.

The most common colour schemes include:

- Red, yellow and white
- Blue and white
- Red, grey and white
- Blue, orange and white
- Yellow, grey and white.

If you’re not sure what colour scheme to choose, surf the internet and find a website that you like. You can then model your colour scheme on what already exists.

2. Use templates.

Can’t find a website you really like? Another option is to choose a template. There are many templates or pre-set designs. These come as part of your web design software (such as FrontPage) or you can check out some websites that specialise in designing templates.

3. Provide an easy to use navigation system.

This is one of the most important issues to consider when designing a website. You need to ensure your visitors can find what they are looking for easily. Most websites either display their navigation bar on the left or at the top. And since most people are used to this type of navigation, it’s best to stick with it.

It also helps to include your navigation bar at the bottom of each page to save your visitors from having to scroll back to the top.

4. Don’t go overboard on special effects

Whilst it is ok to have one or two special effects to jazz up your website, spinning graphics and logos often distract your visitor from the content, not to mention they can take too long to download. Your visitors may click away even before your spinning logo finishes loading.

5. Backgrounds

Ensure your visitors can read the text on the background, ie. no black writing on dark blue background or yellow on white. Also be careful that your links are visible before and after being visited. The default for links in most programs is blue (before being visited) and burgundy (after being visited), so if you have a dark background, ensure your links are light.

6. External Links

It is a good idea to open links to other websites in a new window. That way your visitors can easily return to your site when they are finished browsing the external link

7. Site Map & Search Feature

If you website is more than 15 pages, it is useful to have a site map or a “Search” feature to ensure your visitors can easily find what they’re looking for.

8. Content is King

While it is important that your website looks clean and professional, it is far more important that you concentrate your efforts on the content and promotion.

If you want a professional website, things to stay away from include:

1. Flash intros, revolving globes, bevelled line separators, animated mail boxes
2. Loads of pop up or pop under boxes
3. Autoplay music. Allow your customer to play music only if they choose.
4. Hit counters of the free variety, which say “you are 27th visitor”
5. Date and time stamps, unless your website is updated daily or weekly
6. Busy backgrounds.

If you'd like to sit back and relax let us do the hard work for you, contact CNC Web Solutions for a free quote !

fbfcn

2010-02-12T18:26:00.001-08:00

Everyone needs a little more fbfcn in there life

Exam

2009-11-12T07:15:00.001-08:00

Busy studying for an exam, no blog posts for about a week (MS 70-432)

ASP.NET Menu

2009-11-02T11:07:00.000-08:00

So I wanted a menu that didnt involve redirects, and really liked the idea of just switching out a user control.

So my approach that works for what i needed:

protected void Menu1_MenuItemClick(object sender, MenuEventArgs e)
{
      ContentPlaceHolder mpContentPlaceHolder;
      mpContentPlaceHolder = (ContentPlaceHolder)this.FindControl(”cphMaster”);
      if (mpContentPlaceHolder != null)
     {
            foreach (Control userControl in mpContentPlaceHolder.Controls)
           {
                  if (userControl.GetType() != typeof(LiteralControl)) //hide all controls
                  userControl.Visible = false;
           }
     }

     Control uc;
     switch (e.Item.Value)
     {
           case “Home” : //menu command
           uc = mpContentPlaceHolder.FindControl(”ucStatus”);
           uc.Visible = true;
           break;
           //etc….
     }

so basically every time a menuitem is clicked all user controls are hidden and the menuitem that was selected becomes the visible control.