text:
Author's note: Following are some of the hacks from my book that stand out to me for different reasons. "Master the Command Window" (Hack #46) is one of the most time-saving and keyboard-friendly parts of Visual Studio. "Create Comments Faster" (Hack #69) is one of my favorite hacks since it covers one of my all-time favorite add-ins and is written by Roland Weigelt, creator of the add-in. "Run Unit Tests Inside Visual Studio" (Hack #93) covers one of my other top picks for add-ins, TestDriven.NET. It's one of the only add-ins that can really affect the way that you go about writing code. "Hack the Project and Solution Files" (Hack #4) is an interesting hack because it covers one of the undocumented parts of Visual Studio. I also selected "Refactor Your Code" (Hack #14) because it covers what I think is hands-down the best new feature in Visual Studio 2005, the Refactor menu.
Related Reading
Visual Studio Hacks
Although Visual Studio is, er...well, rather visual, command-line junkies don't need to fear it.
Visual Studio has hundreds of menus, windows, and dialog boxes. This you are probably aware of; what you may not be aware of is that you can avoid using all of these and use the command line inside the command window instead. This hack looks at some of the different commands available to you, how to use existing aliases, and how to create and manage your own aliases.
So why would you want to use a command window when you could just use some part of the IDE? Using the command window is sometimes faster than using the IDE, and when you are writing code with both of your hands on the keyboard, it is often easier and faster to type a command than to reach for the mouse. Many people who are used to the good old days of the command prompt find themselves right at home with the command window, but whether or not you are one of these people, I encourage you to explore its functionality.
The main keystroke to remember is Ctrl-Alt-A (View.CommandWindow); this is the shortcut to open the command window.
open command is the first command I am going
to cover. Using the
open command, you can open any
file in either the filesystem or the current solution. (I think the
real added value here is opening a file in the current solution,
since the command window provides IntelliSense.) Figure 6-2 shows the command window and the
IntelliSense available for
open command.
Figure 6-2. Command Window open command
This might not seem like much, but if you have a dozen projects with hundreds of files, this becomes much faster than digging through the Solution Explorer with your mouse.
You can use any Visual Studio command directly through the command window (through this book, whenever we mention a keyboard shortcut, we've also been mentioning the command). Any command can be used through the command window.
Twenty of the most useful commands are shown in Table 6-1. You can either type the full command or use the alias.
Opens the file specified as a parameter
Creates and opens a new file
Creates and opens a new project
Creates and adds a new project to the current solution
Saves all the currently open files
Closes the selected file
Switches to full-screen mode in the IDE
Shows the toolbox window
Shows the properties window
Skips to the corresponding brace (e.g., the closing brace of an if statement)
Selects all the text in the current document
Equivalent to Edit → Undo
Equivalent to Edit → Redo
Jumps to the next bookmark
Jumps back to the previous bookmark
Collapses all collapsible section of code (classes, regions, etc.)
Builds the current solution
Shows the value of the variable passed in as a parameter
Displays the quick watch dialog for the variables passed in as a parameter
Lists all currently defined aliases or defines a new one
When in doubt, you can sometimes fall back on old
command prompt habits: for instance, the command
cls will clear the command window. You can
find a complete list of commands in the Tools → Options
→ Keyboard screen [Hack #24] .
Perhaps the most useful function of the command window is the ability to use it to view the values of variables during the debugging process. You can use a number of different commands during the debugging process to read and set the values of variables. You can simply type a question mark, a space, and then the name of a variable, and when you press Enter, the value of that variable will be printed to the screen. Here is an example of this command:
? i
In this example, the value of the variable
i is
zero. You can also set the value of a variable through the command
window by using the question mark, a space, the name of the variable,
and then an equals sign and the value that you want to set the
variable to. Here is an example of setting the value of a variable
through the command window:
? i =2
As an alternative to using the question
mark, you can also set the command window to immediate
mode; this turns the command window into an
immediate window and you no longer need to use a question mark. You
can set the command window to immediate mode by typing in the command
immed. Following is a transcript of using the
command window in immediate mode:
To switch the command window back into command
mode, you simply need to type in any command prefixed with
>. For instance, you could type
>cmd and the window would switch back to
command mode.
Another benefit to viewing the value of a variable in the command window is that it is easy to copy the value of that variable out of the command window. If you are working with a large string of XML, it might be valuable to get the value of that XML document and then copy it to your favorite XML application to view the data in a friendlier format.
Aliases are a way of creating a custom
command that is short for a longer command. The
Open command shown earlier is actually an alias
that Visual Studio defines for the more verbose command
File.OpenFile. To create new aliases you simply
need to type
alias, the name of the alias,
then the command that you want to execute for this alias. Here is an
example of creating an alias for the
Edit.SelectAll command:
>alias selectall Edit.SelectAll
You can now select all the text on the screen by calling the alias
selectall. You can also create aliases that
include a parameter for a command. You can create a command called
openClass1 that calls the
File.OpenFile command and also
specifies which file to open. Here is an example of this command:
alias openClass1 File.OpenFile Class1.cs
This way you can call the
openClass1 command at any time to open the
Class1.cs file. You can also remove aliases that
you have already created by simply adding the
/delete switch at the end of the alias
command. Here is an example of how to remove the
openClass1 alias:
alias openClass1 /delete
While you can create and edit aliases directly in the command window, the VSTweak power toy provides an easy-to-use graphic interface for these command window aliases. Using this interface, you can add, edit, or delete command window aliases.
The VSTweak power toy is one of the more useful power toys for Visual Studio and is the subject of a number of different hacks in this book. The VSTweak power toy [Hack #13] can be downloaded from http://workspaces.gotdotnet.com/vstweak. Figure 6-3 shows an example of this interface.
Figure 6-3. The VSTweak Alias Manager
Using the Alias Manager, you can create, edit, and delete aliases using a nice graphical interface. The Available Commands button will show all of the available commands that you can create aliases for. The View File button shows the aliases.ini file, which stores all of the command window aliases.
The command window offers a lot of features that can be used to increase your productivity while working with Visual Studio, particularly when debugging.
There are boring parts of the XML commenting process that you can automate to make documentation more fun (and more likely to happen).
The problem with XML documentation
comments is that somebody has to write them. Even worse, often enough
that someone is you. The Visual Studio IDE helps you by preparing an
empty template when
you type
/// in front of a method, but in the end
you still have to fill in the blanks.
Here's an example. Imagine a method "AppendHtmlText" that is used to append HTML text to some sort of buffer. This method has several overloads, and one of these overloads has a parameter of type "HtmlProvider". This is what Visual Studio will create when you start writing a new XML documentation comment:
/// <summary>
/// </summary>
/// <param name="htmlProvider"></param>
public void AppendHtmlText(HtmlProvider htmlProvider)
You would then add your text, so the XML documentation comment could, for example, look something like this:
/// <summary>
/// Appends the HTML text of the specified provider.
/// </summary>
/// <param name="htmlProvider">The HTML provider.</param>
public void AppendHtmlText(HtmlProvider htmlProvider)
This is a typical method that comes by the dozen: the method name pretty much says what it is doing and you definitely do not need much imagination to write the comment—after some time, these methods become a real drain to document. On the other hand, you simply have no choice. If you want the benefits of XML documentation comments (perhaps a nice help file generated by NDoc [Hack #71] ), you have to comment all public (and protected) members, period.
Let's take a closer look at the earlier example. The method is written according to Microsoft's Design Guidelines for Class Library Developers; some of these rules are:
Identifier names consisting of multiple words are written in PascalCasing (the method name) or camelCasing (the parameter name).
Acronyms are treated like normal words and are formatted accordingly (for example, "Html" instead of "HTML").
Identifier names do not contain abbreviations.
Method names usually start with a verb.
Now when you look at this set of rules on one hand and the documentation you have written on the other, it is pretty safe to say that a large part of the documentation could have been generated automatically.
GhostDoc is an add-in for Visual Studio .NET 2003 that tries to do just that. With GhostDoc installed, you move the cursor into the method or property you want to document, invoke the Document This command using either the source editor's context (right-click) menu or a hotkey, and GhostDoc will create an XML documentation comment. The result for the previous example would be:
/// <summary>
/// Appends the HTML text.
/// </summary>
/// <param name="htmlProvider">The HTML provider.</param>
public void AppendHtmlText(HtmlProvider htmlProvider)
Pretty close—but how does GhostDoc do that? First of all, it's important to note that the add-in has no idea of what the identifiers actually mean—GhostDoc simply assumes that the code is written according to the guidelines and does the following:
It breaks up identifier names into single words by analyzing the casing.
A word consisting of only consonants (for example, "HTML") is automatically treated as an abbreviation (other abbreviations, for example, "UML," can be specified explicitly).
For methods, the first word is treated as a verb and thus an s (in some cases es) is added.
A "the" is added between the first and the second word of the method name (unless the second word belongs to a configurable list of words that are never preceded by a "the").
After GhostDoc has created the XML documentation comment, the
developer has to edit only a few details (for example, for the
AppendHtmlText method, add "using
the specified provider" to the end of the sentence)
before moving on to the really interesting part of the documentation:
remarks on usage, references to related methods or properties,
example code—information that cannot be created automatically.
GhostDoc is driven by generation rules. When an XML documentation comment is about to be generated, the add-in will collect information about the code element (method, property, indexer, etc.) like name, return type, parameter names and types, and so on. This information is then compared to a set of rules, and the rule that fits best is then used to generate the documentation.
With each version of GhostDoc, the number of rules grows; the more specialized they are (for example, rules for handling Boolean properties, methods with a name consisting of only one word, etc.), the better the results.
Here are a few more examples that show only a part of what GhostDoc can automatically generate:
Note that the rule for indexers takes the name of the parameter into account, so it is "at the specified index", but "with the specified name":
/// <summary> /// Gets the <see cref="System.String"/> at the specified index.
/// </summary> /// <value></value> public string this[int index]
get { ... }
If you comment Boolean properties in .NET Framework documentation style, you will definitely recognize the "Gets or sets a value indicating whether..." rule, and most likely you already have stopped counting the times you have typed this phrase:
/// <summary> /// Gets or sets a value indicating whether
/// this <see cref="Demo"/> is cool.
/// </summary> /// <value> /// <c>true</c> if cool; otherwise, <c>false</c>.
/// </value> public bool Cool
get { return true; }
set { ; }
The so-called "of the" reordering is triggered by specific words such as "size," "length," or "name" (the list of trigger words can be configured):
/// <summary> /// Determines the size of the page buffer.
/// </summary> /// <param name="initialPageBufferSize">
/// Size of the initial page buffer.</param>
/// <returns></returns>
public int DeterminePageBufferSize(int initialPageBufferSize)
First, you will need to download and run the GhostDoc installer from http://www.roland-weigelt.de/ghostdoc.
After running the GhostDoc installer, the next time you start Visual Studio, a couple of configuration dialogs appear to complete the setup (for example, choose a hotkey). Note that GhostDoc cannot install a hotkey if Visual Studio is not already using a custom keyboard scheme—this is a limitation of Visual Studio's extensibility model. If you are not sure, simply try to assign a hotkey; if GhostDoc setup encounters a problem, it will tell you what to do.
GhostDoc comes with a C# source file that demonstrates the features of this add-in; simply load the demo project, which can be found in a subdirectory of the folder GhostDoc was installed to. Inside Visual Studio, open the Demo.cs C# file, move the cursor into the body of a method, for example, and invoke the Document This command. The Document This command can be invoked using the hotkey, from the right-click menu, or from Tools → GhostDoc → DocumentThis.
After you invoke the Document This command, GhostDoc will go to work and generate as much of your XML comments as it can.
Certain aspects of GhostDoc can be configured:
Which words are treated as acronyms
Which words must not be preceded by "the"
Which words trigger the "of the" reordering of an identifier name's words
The fixed parts of the generated texts.
You can edit the configuration settings in the dialog that is opened Tools → GhostDoc → Configure GhostDoc. This dialog is shown in Figure 8-2.
Figure 8-2. GhostDoc Configuration dialog
In this dialog, you can also export settings to a file that can then be imported on a different computer. This is pretty handy if, for example, you want to keep the configurations at home and at work in sync.
—Roland Weigelt
Testing can be just a few clicks away when you use TestDriven.NET to run unit tests right inside of Visual Studio.
Test Driven Development is the practice of writing unit tests for your code before you actually write that code. By writing a test and then writing the code to make that test pass, you have a much better idea of the goal and purpose of your code. Test Driven Development also encourages complete code coverage, which not only increases the quality of your code, but also allows you to refactor the internals of a method or class and quickly and easily test the outside interface of the object.
TestDriven.NET is a unit-testing add-in for Visual Studio. It was developed for a number of years under the name NUnitAddIn. It now supports multiple unit testing frameworks and is compatible with all versions of Visual Studio .NET. It is available in free and professional versions from the TestDriven.NET web site at http://www.testdriven.net. Its author, Jamie Cansdale, keeps a web log charting TestDriven.NET's development at http://weblogs.asp.net/nunitaddin.
TestDriven.NET can be installed using an administrator or limited user account. By default, it will install for just the current user. Because limited users don't have write access to the Program Files folder, a limited user installation will install files in the user's Application Data\TestDriven.NET folder. An administrator installation will install files in the Program Files\TestDriven.NET folder. These defaults can be changed by selecting Custom on the Choose Setup Type page.
TestDriven.NET is packaged with functional versions of the NUnit and MbUnit unit testing frameworks. It also includes an adapter for executing Visual Studio Team System unit tests when available. These will be installed to subdirectories inside the TestDriven.NET directory, as shown in Figure 13-2.
Figure 13-2. TestDriven.NET Setup
The Run Test(s) command offers a straightforward way to build and run tests. It is intended to be the default method of test execution in most contexts. It automatically detects the test framework being used and executes tests using the correct test runner. The tests are launched by a test execution engine running as an external process. This test process is kept alive in order to improve execution times on subsequent runs. Once a test process has been cached, a rocket icon will appear in the notify box.
If the code editor window is selected, the test(s) to execute will be determined by the position of the caret. Individual tests are executed by right-clicking anywhere inside a test method and selecting Run Test(s), as shown in Figure 13-3. All tests in a test fixture are executed by right-clicking inside a class (but outside of any method) and selecting Run Test(s). All tests in a namespace are executed by right-clicking inside a namespace and selecting Run Test(s).
Figure 13-3. Run Test(s) menu item
The Run Test(s) option is also found on various Solution Explorer context menus. It can be used to execute all tests in a solution, project, or project item.
Ad hoc tests offer a useful alternative to throwaway console applications. They should not in any way act as a substitute for real unit tests. Rather, they are intended to provide a convenient way of exploring local private methods or third-party code.
Any method that does not take parameters
can be executed as an ad hoc test simply by right-clicking inside it
and selecting Run Test(s). It can be a public, private, static, or
instance method. In the case of an instance method, an object will be
created using the default constructor of the class (providing, of
course, that the class has a default constructor). The
Dispose method will be called on any object that
IDisposable, once the test has been
If an ad hoc test returns an argument, the argument will be expanded to the Test output pane. Complex objects will have their fields and properties displayed. Enumerable objects will be listed. Primitive objects will be converted to strings and displayed.
The Test output pane is the window in which all test results and warning messages appear and is shown in Figure 13-4. Trace and debug information is also sent there, along with console output and error messages. If all tests in a project or solution are being executed, the Test output pane will display only ignored or failed tests.
Figure 13-4. Output Test pane
When a test fails, the name of the test, together with the exception message and stack trace, is displayed. If code has been compiled with debugging information, the corresponding portions of the stack trace will contain line numbers. Double-clicking on these portions is a convenient way of navigating to the offending code.
As well as sending information to the output pane, failing tests also get added to the task list. If many tests have failed, this creates a useful summary view as shown in Figure 13-5. Generally, the further up the stack trace, the more likely the code will be of interest. Double-clicking a test in the task list is an alternative way of accessing the code in question.
Figure 13-5. Task List view
The Test With... menu offers many alternative contexts in which to run tests. Selecting the Debugger context executes test(s) with the Visual Studio debugger attached, as shown in Figure 13-6. By setting a breakpoint on a method and selecting Test With... → Debugger, it is possible to step into a unit test.
Figure 13-6. Debugger command on Test With... submenu
By default, Visual Studio will build all projects in a solution when executing with the debugger. In Visual Studio .NET 2003 and Visual Studio 2005, there is an option to "Only build startup projects and dependencies on Run". Checking this option can significantly improve startup times when debugging large solutions. In Visual Studio .NET 2003, this option is under Tools → Options → Environment → Projects and Solutions. In Visual Studio 2005, it can be found under Tools → Options → Environment → Projects and Solutions→Build and Run.
By right-clicking on a project in the Solution Explorer window and selecting Run Test(s), all tests within that project will be executed. Failed and ignored tests are sent to the Test output pane and task list in a similar fashion to other Run Test(s) commands. Trace, debug, and console output is suppressed when executing all tests in a project or solution.
Similarly, all tests in a solution can be executed by right-clicking on the solution in the Solution Explorer window and selecting Run Test(s). For each project in the solution, the test framework being used is established and tests are executed using the correct test runner. Projects that do not contain any tests are simply ignored.
When a test run is in progress, an Abort Test menu item will appear on the Tools menu, as shown in Figure 13-7. Selecting this item will abort the thread the tests are executing on. When tests are aborted in this way, any cleanup logic is given a chance to run.
Figure 13-7. Abort Test command on Tools menu
You will sometimes need to stop the test process. The most common of these circumstances is when an app domain is created, but not unloaded by a test run. This can result in any assemblies loaded by the app domain being locked, which causes subsequent builds to fail. It is possible to recycle the test process by right-clicking on the rocket icon in the notify box and selecting Stop, as shown in Figure 13-8. A new test process will be launched the next time the Run Test(s) command is executed.
Figure 13-8. Stopping the test process
—Jamie Cansdale
Discover the format of these two Visual Studio files and learn about a tool to convert these files between versions of Visual Studio.
Solution and project files are an essential part of working with Visual Studio. You will almost always work with the solution and project files through the IDE, whether adding projects to your solution or configuring your project. The purpose of this hack is to describe the format of these files for two reasons. If your project or solution files become corrupted, knowing the structure of these files might help you fix the file without having to re-create the entire project or solution. Also, knowing the structure of these files will help you if you want to convert these files or write a tool that works directly with these files.
WARNING You must edit these files with extreme care. The format of these files is not published or documented and could change drastically in future versions. You should normally need to work with these files only through the IDE, and unless you find a compelling reason to, I would not directly edit these files. If you are interested only in converting the version of these files, then you may want to look toward the end of this hack under Section 1.5.3 to read about a tool that will do the conversion for you.
Visual Studio creates two separate files when you create a new solution in Visual Studio. The first file is the .suo (solution user options) file, which stores user settings such as the location of your breakpoints. This file is stored in binary format, which does not lend itself to easy editing. Since there are no compelling reasons to edit this file, I am not going to document the format of it here. If you think that this file is preventing your solution from opening, you can actually delete the file and Visual Studio will create a new one when you open the solution and save it when you close the IDE. By deleting the file, you will lose any of your user-specific settings like breakpoints, but this is a small price to pay for saving your solution. The .suo file is a hidden file, so you will need to make sure Windows Explorer is configured to show hidden files (this can be set through Tools → Folder Options → View in any Explorer window).
The second file that Visual Studio creates is the .sln file. This file stores information about the projects that make up this solution, source control settings, and other global settings that apply to all of the projects in the solution.
The first line of the solution file contains a declaration including the version of Visual Studio that this solution is built for:
Microsoft Visual Studio Solution File, Format Version 8.0
The version number used in the solution file is a little different than the version number you are used to seeing in the Visual Studio product name. Visual Studio .NET 2002 solution files have a version number of 7.0. Visual Studio .NET 2003 solution files have a version number of 8.0 (as opposed to the 7.1 number you are used to), and Visual Studio 2005 solutions files have a version number of 9.0. Visual Studio 2005 Beta 1 contains an additional line under this first line, which contains just the following:
# Visual Studio 2005
This line causes the icon of the file to be changed to a Visual Studio 2005-specific icon, and if removed, will prevent Visual Studio from opening this file when you double-click on it.
The next portion of the solution file contains a section for each of the projects that are contained in this solution:
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HacksWinApp",
ProjectSection(ProjectDependencies) = postProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "HacksLib",
"HacksLib\HacksLib.csproj", "{89EE0E8E-C5C6-4772-A5EE-D347E40FB0E4}"
ProjectSection(ProjectDependencies) = postProject
You can see that the syntax of the file is somewhat similar to Visual
Basic. Each project has a
Project and
EndProject tag as
well as a
ProjectSection tag to track the
dependencies for the project. The first
GUID in the project
tag is used to identify what type of project this is. In this
instance, the GUIDs for both a C# Windows Forms project and a C#
library project are the same, since these project types are really
the same except for the output type setting. The strings on the right
side of the equals sign include the name of the project, its path
relative to the solution root, and the unique GUID for this project.
This GUID is used for a number of things including tracking
TIP: You can view a list of all the project GUIDS by opening regedit (Start → Run, then type
regedit) and navigating to HKEY_LOCAL_MACHINE\SOFTWARE\Microsoft\VisualStudio\7.1\Projects.
Under this key are all the GUIDs for the project available on your machine; the name and the extension of the project are listed as well.
In Visual Studio .NET 2003 and Visual Studio 2005, project dependencies are also tracked here. These are not the implicit dependences that are created by project references. When Project A references Project B, there is an implicit dependency. Project B must be built before Project A since it references the other project's output. Since this type of dependency is project-specific information, it is stored in the project file. (In this example, it would be stored in Project A's project file since it is referencing Project B, rather than the solution file we are looking at here.) Project files and dependencies are described in the next section.
The dependences stored in the
ProjectSection tag
are configured at the solution level. They define when a project must
be built before another project, but they may not directly reference
each other. This is stored in the
tag of the project that is dependent on the other project. In this
example, the HacksWinApp project is dependent on
the HacksLib project and thus includes a
reference to the GUID of the other project. This dependency is
normally configured by right-clicking on the solution file, selecting
Properties from the context menu, and navigating to Project
Dependencies in the property page that appears.
Visual Studio .NET 2003
includes a
ProjectSection tag even if there is no
dependency (you can see this in the
project tag). Visual Studio 2005 completely omits the
ProjectSection tag if there are no dependencies
for the project. Visual Studio .NET 2002 stores the dependency
information in a completely different section of the solution file,
which we will cover next.
The next section in the solution file is the
Global section, which begins with a
Global tag and ends with an
EndGlobal tag. Inside these tags are a number of
GlobalSection tags that store an array of different
pieces of information, including the configuration settings for
various projects as well as source control information. Here is a
look at the Global section of this example solution file from Visual
Studio .NET 2003:
GlobalSection(SolutionConfiguration) = preSolution
Debug = Debug
Release = Release
GlobalSection(ProjectConfiguration) = postSolution
= Debug|.NET
= Debug|.NET
= Release|.NET
= Release|.NET
= Debug|.NET
= Debug|.NET
= Release|.NET
= Release|.NET
GlobalSection(ExtensibilityGlobals) = postSolution
GlobalSection(ExtensibilityAddIns) = postSolution
SolutionConfiguration and
ProjectConfiguration sections contain the
configuration settings for the solution and its projects. The
ExtensibilityGlobals and
ExtensibilityAddIns sections are included for the
benefit of add-in authors. The
ExtensibilityGlobals section can be used to store
global information about the solution, and the
ExtensibilityAddIns section lists all
add-ins that are used in this solution.
Visual Studio .NET 2002 also uses the
section to store information about project
dependences. Here
is an example of that configuration section:
GlobalSection(ProjectDependencies) = postSolution
This section simply specifies that the project identified by its GUID on the left of the equals sign depends on the project identified by its GUID on the right side of the equals sign.
Visual Studio 2005 includes an additional section that is not present in any of the older versions of Visual Studio; it's shown here:
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
If the FALSE is switched to TRUE, then the solution node is hidden in the IDE.
Each project creates a number of files to store information about itself. This includes a project file and a user settings file. The extension for the project file is based on the language type; for example, a C# Project is saved with the extension .csproj and a VB.NET Project is stored with the extension .vbproj. Thankfully, the internal formats of these various files are based on the same XML schema. The beginning of each project file includes some basic information about the project, including the version of Visual Studio that it was created for as well as the GUID for this project. Here is an example of this section:
ProjectType = "Local"
ProductVersion = "7.10.3077"
SchemaVersion = "2.0"
ProjectGuid = "{89EE0E8E-C5C6-4772-A5EE-D347E40FB0E4}"
This is from a Visual Studio .NET 2003 project file, which is why the
ProductVersion is set to 7.1 and the
SchemaVersion is set to 2.0. In Visual Studio .NET
2002, the
ProductVersion would be 7.0 and the
SchemaVersion would be 1.0. These settings are no
longer relevant in Visual Studio 2005 as project files are now
MSBuild files.
TIP: Notice that the version number used for Visual Studio .NET 2003 is 7.1 in the project file and 8.0 in the Solution file.
The next
section of the project file is the
Build section,
which includes build settings and configuration settings as well as
references information. Here is the
Build settings
ApplicationIcon = ""
AssemblyKeyContainerName = ""
AssemblyName = "HacksLib"
AssemblyOriginatorKeyFile = ""
DefaultClientScript = "JScript"
DefaultHTMLPageLayout = "Grid"
DefaultTargetSchema = "IE50"
DelaySign = "false"
OutputType = "Library"
PreBuildEvent = ""
PostBuildEvent = ""
RootNamespace = "HacksLib"
RunPostBuildEvent = "OnBuildSuccess"
StartupObject = "">
As you can see, this section includes information like the
AssemblyName and
OutputType of the project. The
next part of the
Build section is for the various
build configurations:
Name = "Debug"
AllowUnsafeBlocks = "false"
BaseAddress = "285212672"
CheckForOverflowUnderflow = "false"
ConfigurationOverrideFile = ""
DefineConstants = "DEBUG;TRACE"
DocumentationFile = ""
DebugSymbols = "true"
FileAlignment = "4096"
IncrementalBuild = "false"
NoStdLib = "false"
NoWarn = ""
Optimize = "false"
OutputPath = "bin\Debug\"
RegisterForComInterop = "false"
RemoveIntegerChecks = "false"
TreatWarningsAsErrors = "false"
WarningLevel = "4"/>
This section includes configuration-specific build settings. The
project file will usually contain at least a
Release section. The next part of the
Build section contains all of the references for
this project. Here is an abbreviated example of this section:
Name = "System"
AssemblyName = "System"
HintPath = "..\..\..\..\..\..\..\..\..\..\WINDOWS\Microsoft.NET\
References section contains a reference tag for
each assembly referenced by the project. Starting with Visual Studio
2005, you can create a reference to either an assembly or an
executable, which comes in very handy when you are trying to
unit-test a Windows application, since this lets you directly
reference your application. To get this same functionality in Visual
Studio .NET 2003, you can actually hack the project file to create a
reference to an executable—you simply need to manually enter a
reference tag in the references element pointing to your executable.
Your new reference tag would look exactly like this example, except
it would be pointed to an .exe file instead of a
.dll file.
After the
Build section is
Files section of the project file, which can be
seen here:
RelPath = "AssemblyInfo.cs"
SubType = "Code"
BuildAction = "Compile"
RelPath = "Class1.cs"
SubType = "Code"
BuildAction = "Compile"
This section simply tracks all of the files that are included in this project. The schema of the project file is pretty straightforward in case you need to edit it directly.
Visual Studio also creates a user-specific project file much like the .suo file created for the solution file except with an extension of <projectextension>.user, so if you were using VB.NET, it would be vbproj.user. Similarly, this user-specific file does not contain anything pertinent enough to cover here, and is also hidden by default, so you will need configure Windows Explorer to show hidden files through Tools → Folder Options → View.
Visual Studio 2005 has not been mentioned up until this point because the project files in Visual Studio 2005 are completely different than the project files in Visual Studio .NET 2002 and 2003. The project files in Visual Studio 2005 are MSBuild XML files. MSBuild is the new build tool used in Visual Studio 2005 and is a completely different, complex topic that is not going to be covered here. It is similar to NAnt in that is uses XML files to describe how the project should be built.
Visual Studio does an excellent job of converting files from older versions to newer versions. For instance, if you open a Visual Studio .NET 2002 solution in Visual Studio .NET 2003, it will first ask if you want to convert the solution. After you say yes, it will convert all of your solution and project files to the new version of Visual Studio .NET. Now what if you accidentally converted those files and didn't have a backup? Or perhaps you are writing a solution in Visual Studio .NET 2003 and find out that your client has only Visual Studio .NET 2002? One method would be to create a new solution in the old version, create an identical project structure, and then copy all the files over and add them to their respective projects. Thankfully, there is a better solution. There is a tool available that will automatically convert the project and solution files for you as well as the .resx files if you are using Windows Forms.
The tool is called Visual Studio Converter 2.0 and can be downloaded from http://www.codeproject.com/macro/vsconvert.asp.
This tool is simple to use. Figure 1-15 shows an example of this conversion tool's user interface.
Figure 1-15. Visual Studio Converter 2.0
To convert files, you first need to click the Add Files button and select all the solution, projects, and .resx files for your solution. For a simple, one-form C# Windows Forms application, you would need to include the .sln, .csproj, .csproj.user, and Form1.resx. You will have an additional .resx file for each form in your application. Next, you need to click one of the two conversion buttons to convert the files to either Visual Studio 7.0 (2002) or Visual Studio 7.1 (2003). When initially converting a 2002 project to the 2003 format, it is best to use the Visual Studio conversion process. After this initial process, this tool is a great way to convert the files back and forth as needed.
Currently, it converts only between Visual Studio .NET 2002 and Visual Studio .NET 2003.
Visual Studio 2005 puts this fundamental tenet of Extreme Programming into action. Use it to write better code.
Refactoring is a technique for improving a section of code by modifying its internal structure, but without affecting its external behavior. Refactoring is one of the key tenets of Extreme Programming; in a rapid development methodology, the idea is to create code quickly and then refactor it as you work with it. The goal of Extreme Programming is to create better quality code by concentrating on small deliverables and continuously testing and refactoring your code. Refactoring is not just limited to Extreme Programming—it is a valuable practice regardless of the methodology you happen to subscribe to. Visual Studio 2005 introduces a new Refactor menu. This menu is available whenever you right-click and provides a number of time-saving and code-improving functions.
TIP: Refactoring is almost exclusively a C# feature. The only part of the Refactor menu that is available in VB.NET is the Rename function.
Figure 2-31 shows the menu and the various functions included there.
Figure 2-31. Refactor menu
The first function available in the Refactor menu is Extract Method. This can be used to select a block of code and then extract that code into a separate method. This function has a number of applications, such as removing a section of code that deserves to be in its own method for code reuse purposes. Here is some existing code:
public class Car
private bool _isStarted = false;
private bool _hasFuel = true;
public Car( )
//Start the Car
if (_hasFuel){_isStarted = true;}
That example has a little bit of code in the constructor that checks
to see if the car has fuel and then
"starts" the car by setting a
Boolean value. If you decide that this class needs a second
constructor, instead of duplicating this tiny piece of logic, you
could extract this into a separate
StartCar method
and then call that method from both constructors. To accomplish this
with the Refactor menu: highlight the code you want to extract and
then right-click and select the Extract Method function from the
Refactor menu. After you select Extract Method, you see a dialog box
that asks for the name of the new method (see Figure 2-32).
Figure 2-32. Extract Method dialog
Type in the new name of the method, in this case,
StartCar, since it describes exactly what the
method will accomplish. After you click OK, Visual Studio will modify
the selected code by placing it in a new method named
StartCar, then placing a call to the new method in
the spot where the old code was. Here is the new code:
public Car( )
//Start the Car
StartCar( );
private void StartCar( ){if (_hasFuel){_isStarted = true;}}
The second
on the Refactor menu is the Rename function. This is one of the most
time-saving functions on this menu. Suppose that you decide the name
Car is a little shortsighted, since the system
will need to work for
Trucks, and more. A more
appropriate name would be
Vehicle. Normally you
would need to manually find all references to the name
Car and change them; the Rename function does this
for you automatically. First, right-click on the name
Car and then select the Rename function from the
Refactor menu; the Rename dialog will then be displayed (see Figure 2-33). The Rename dialog allows you to specify what
to rename the class to; in this case, it's going
Car to
Vehicle. A number
of checkboxes are available; check all of them in this example. The
first (Preview Reference Changes) lets you preview all of the changes
to the files; the next two checkboxes (Search In Comments/Strings)
tells Visual Studio to search for this name in comments as well as
Figure 2-33. Rename dialog
After clicking the OK button, you will see a confirmation dialog that
shows all of the changes that will be made. As you can see in Figure 2-34, the Preview Changes dialog shows where Visual
Studio is going to change the name
Car to
Vehicle. After you click Apply, Visual Studio will
make all the changes to the project.
WARNING One thing that Visual Studio does not change is the name of the
StartCarmethod. Since Visual Studio does not look in method names when making these changes, you will have to change
Figure 2-34. Preview Changes dialog
In addition to being a great time-saver, Rename removes any excuse you might make about why a class is not named appropriately.
The Encapsulate Field function creates a
public property that encapsulates your
In the ongoing example, suppose that you need to create a public
property for the
_isStarted field. To do this,
right-click on the field name and click the Encapsulate Field
function on the Refactor menu. You are then shown the Encapsulate
Field dialog, which is shown in Figure 2-35.
Figure 2-35. Encapsulate Field dialog
Visual Studio automatically sets the property name to be
IsStarted and gives you the option to update
references to the old field. Leave this setting as External so that
code in your class is not changed to reference the public property
and instead continues to use the private field. The other checkboxes
are similar to the ones you saw in the Rename dialog and perform the
same actions. After you click OK, you are shown a Preview Changes
dialog--the same kind of dialog shown in Figure 2-34—which shows all of the
changes that will result. After you accept the changes shown, the following code
is added to the class:
public bool IsStarted
return _isStarted;
_isStarted = value;
This function comes in handy even when you are not refactoring. When creating a class for the first time, you can create the private fields and then use this function to create all of the necessary public properties.
The Extract Interface function
looks at your current
class and creates an
interface based on its public methods and properties. For example,
suppose you want to create an interface for objects that can be
"started"; this interface would
include a Boolean property, in this case
IsStarted, which, when set, has the side effect of
"starting" the object (some kind of
vehicle or item with an on/off switch). First, right-click on the
class name and click the Extract Interface menu item; this displays
the Extract Interface dialog, which is shown in Figure 2-36.
Figure 2-36. Extract Interface dialog
The default interface name is
IVehicle; change it
IStart and then select the
IsStarted property. After you click OK, Visual
Studio creates a new file called IStart.cs with
the following piece of code:
interface IStart
bool IsStarted { get; set; }
Visual Studio will also modify the existing class to implement the new interface. The Extract Interface function is a great time-saver when you need to create an interface that is based on a current class.
The next three functions on
the menu all focus on working with parameters. Since the sample class
does not currently contain any methods with parameters, go ahead and
add a new method with a number of different parameters. Here is a
method called
Collision that you can add to this
public void Collision(DateTime CrashDate, int Speed, int DamagePct)
int costMultiplier = 1;
// Do stuff
As you can see, this method has a local variable called
costMultiplier and sets the value to
1. But suppose that
costMultiplier varies from vehicle to vehicle. In
this case, you'd want to pass in this multiplier as
a parameter instead of creating it as a local variable. The first of
the parameter refactoring functions will do just that. First,
right-click on the
costMultiplier variable and
select the Promote Local Variable
to Parameter function. This will take
the local variable and add it as a parameter to the method. Here is a
look at the modified code:
public void Collision(int costMultiplier, DateTime CrashDate,
int Speed, int DamagePct)
// Do stuff
You may be thinking that this is not a big deal; it is basically cut and paste. But Visual Studio also goes and looks for any calls to this method and modifies them as well. If you were calling this method before with the following line of code:
Collision(DateTime.Now, 60, 10);
this method call would be changed to the following:
Collision(1, DateTime.Now, 60, 10);
Notice that Visual Studio not only adds the new parameter, but also passes in the value that the local variable was set to as well, saving time and ensuring that existing code continues to work as it did before.
Suppose you decide that you don't need the
CrashDate parameter. If you won't
be using it in the method, you can remove this parameter using the
second of these parameter refactoring
functions, called Remove Parameters. First, right-click on the method
name and click Remove Parameters in the Refactor menu.
You'll be shown the Remove Parameters dialog, which
is shown in Figure 2-37.
Figure 2-37. Remove Parameters dialog
In the Remove Parameters dialog, you can select the
CrashDate parameter, click Remove, and then click
OK. You are then shown a Preview Changes dialog showing the changes
that will be made to any calls to this method. After clicking Apply
on that screen, those changes will be made. Any calls to this method
will have this parameter removed, and the parameter will be removed
from the method signature.
Further, suppose you decide that you don't want
costMultiplier to be the first parameter, but
rather the last parameter. This is where the last of the parameter
functions comes in. First, right-click on the method, then choose the
Reorder Parameters menu item on the
Refactor menu. This will display the Reorder Parameters dialog, which
is shown in Figure 2-38.
Figure 2-38. Reorder Parameters dialog
You can then select the
costMultiplier parameter,
move it down two spots, and click OK. You will again then be shown
the Preview Changes dialog. where you can confirm the changes that
will be made to any calls to this method. Click Apply, and the order
of the parameters will be changed in the method signature and any
calls to this method.
The Refactor menu is a great addition to Visual Studio and will make it much easier to refactor code. If you want to learn more about refactoring, the best resources are the book Refactoring (Addison-Wesley) and the companion web site, http://www.refactoring.com.
Tired of waiting for Visual Studio 2005 or stuck using Visual Studio .NET 2003 for some reason? A number of commercial tools are available that add similar functionality into Visual Studio .NET 2003:
From Jet Brains:
From XtremeSimplicity:
View catalog information for Visual Studio Hacks
Return to ONDotnet.com.
Copyright © 2009 O'Reilly Media, Inc.


text:
OCZ Technology Group, a leading supplier of solid-state drives (SSDs), on Thursday announced that it has shipped its one millionth solid state drive. Since starting to offer SSDs roughly three years ago, solid-state drives became OCZ's major product line and the company canned its traditional DRAM family.
"Solid state drives continue to represent a game-changing technology for both consumers and enterprise clients, and we are proud to achieve this milestone. But most of all, I wanted to take this opportunity to sincerely thank all of our loyal customers and partners, without whom this success would not be possible," said Ryan Petersen, chief executive officer of OCZ Technology.
OCZ offers a broad array of interface options for solid state drives including SATA, SAS, Fibre Channel, PCI-Express, and the proprietary High-Speed Data Link (HSDL). OCZ designs and manufactures SSD solutions to address a wide spectrum of applications from personal computers and high-performance workstations to mission critical enterprise storage arrays.
OCZ started to offer SSDs back in 2008 and gradually the demand towards SSDs has been rising from thousands to tens of thousands of drives per quarter. In order to fulfill the demand towards its solid-state drives, the firm established a new production facility in Taiwan late last year to boost its production capacity to 140 thousand SSD units per month. To further improve its competitive positions on the emerging market, OCZ acquired various solid-state drive-related intellectual property and recently bought Indilinx, a well-known designer of controllers for SSDs.
For Q4 FY2011 OCZ expects to earn $64 million, of which $58 million will account for sales of solid-state drives, which represents approximate increase of 380% year-over-year and 40% sequentially. The expected Q4 SSD product mix in Q4 FY2011 is comprised of 7% consumer, 78% server, and 15% enterprise devices.

subset: commoncrawl


text:
Metro had previously issued daily disruption reports on this page. The reports were created using a manual process that required intensive work by staff. We are currently exploring ways to use technology solutions to allow us to provide disruption information in an online format.
You can check the status of Metro trains throughout the system by viewing the Metrorail service status report. The report describes current Metrorail operating status, including any delays of 10 minutes or more. These same updates are available on the Service Status section of the home page.


text:
Reviewed By Ron M (Brownton, MN) Reviewed for a 2006 Chevy Colorado —5/16/2008 1:05 PM
I have a 2006 Chevy Colorado with high back seats and the 60 - 40 front seat. The passenger side went on easily enough and so did the 60 side except where the cover went over below the center console. There are two short straps that have two kind of acute angle hooks on them. I couldn't find a spot to hook them to so for now they aren't hooked anywhere. I couldn't hardly get my hand under the seat there either. Other than this, it was a pretty easy install and they look really good. There also was no hole to put my backrest lever through so I just grab it with the cover over it. It works this way just not nearly as easily. Overall I'm happy with them.


text:
Philadelphia Phillies (40-45) vs.Pittsburgh Pirates (52-31)
LHP Cole Hamels (2-11, 4.58 ERA) vs RHP Gerrit Cole (4-0, 3.70 ERA)
TIME: 1:35 ET, PNC Park
TV: Comcast SportsNet
Weather: 79, partly cloudy
Media: Twitter and Facebook
Happy Independence Day, America!
The Phils and Bucs celebrate the birth of our fine country with an afternoon game along the banks of the Allegheny River. Cole Hamels looks to once again avoid a career-worst 12th loss of the season. He is pitted against righty Gerrit Cole who, on the flip side, is without a loss in his young career.
Lineup: Revere CF, Utley 2B, Rollins SS, Howard 1B, Brown LF, D. Young RF, Fransden 3B, Ruiz C, Hamels P
Gameday Beer: Yuengling Lager
There's a good chance you'll be trying a variety of summer beers today, as you should on a warm and festive day such as this. Yet at the end of the night when all those beers are gone, it's time to dance with the girl that brought you. We all know the Yuengling story and how it pairs well with everything – so pop a can or bottle and celebrate America's long standing traditions of freedom and beer with a cold one from its oldest brewery.
37 Comments
Leggggo!!! C'mon Phils, lets win in this park!
No excuses for Hamels
Caught stealing 2xs in one inning!!!! Really?
Typical Hamels inning.
Great job by Hamels today, and Delmon Young is having an excellent road trip at the plate..heating up!!
Just saw a typical phillies inning. Utley leads off with a triple. Rollins pops up Howard strikes out. They walk brown and Mayberry hits a weak ground ball. Is it that hard to hot a fly ball ?
I don't know..have you faced 95+ mph fastballs before..
he doesn't get paid to hit 95 mph fastballs
Ok, I understand the job thing, but that doesn't make it routine for a professional hitter..
That's true.. but that's baseball
As hot as the Pirates were coming into this series, 2 out of 3 is pretty good. The Pirates are an interesting team but I think they will come up short against both the Reds and the Cardinals. The team really relies on what has been a very effective bullpen that wasn't that solid in this 3 game series and especially today. If Gerrit Cole was pitching for the Phillies, there is no way that he comes out of the game in the 6th inning having made fewer than 80 pitches and only given up one run. Charlie would just hope that he can pitch his way out of it. Today, the Pirate relief pitchers not only allowed the 2 runners on base to score, they allowed 3 additional runs. When you take good starting pitchers out like Locke and G. Cole in the 6th inning, you are relying on several pitchers to be very effective. Today, they weren't. But the depth of their bullpen certainly is impressive.
First inning shows how much the team misses Davey Lopes coaching first base. Revere has been thrown out 8 times and Rollins has been thrown out 6 times on attempted base steals.
Actually, the Phils' success rate on stolen bases was still the best in the league even after Lopes left.
Though this year hasn't been good, I wouldn't blindly blame that all on missing Lopes. Rollins has slowed, Victorino is no longer on the team, and Revere is still pretty inexperienced, especially in a new league. Last season with the Phils, Pierre had his best rate ever without Lopes to help him.
and Juan Samuel is pretty good
Wben I look at today's lineup and I see a Ben Revere at .290 and inexorably (ahem) moving toward .300, a healthy (for now) Utley at .282 and hitting well, D. Brown being D. Brown and on course to hit 35-40 dingers; Michael Young at a solid .285, Ruiz at .278 and coming along, Delmon Young (who could always hit) heating up at .273 …
And Cole looking today like Cole of "old", and sure not to have 11 losses in the second half, and the possibility of Halladay coming back while Pettibone and Lannan hold the fort, and the possibility of Kendrick continuing to be just being the Kendrick he's been for about a year now …
And given that there are only a couple of really, really good teams in either NL or AL – is this Phillies group, therefore, not a dangerous bunch that, if the stars align, could indeed make a run at a playoff spot? Or is it just me?
It's not impossible Lou, the odds aren't good though. And you didn't mention the bullpen. You'd need galaxies to align to help this bullpen. And yet, they keep me coming back to the tube every night just in case. Oh hell, I've been through so many horrible seasons I'd come back no matter what, I'm just hopelessly hooked.
Nothing wrong with that Lefty..
What got me thinking about this was looking at the Pirates' lineup … you know, the team that some are now actually calling "the best in baseball." Yes they have a good guy here and there but – I'm sorry – I can't get excited about what I see … and then I compare it to the Phillies' position players and I figure WTF we can match up with that.
As to the bullpen … for sure, but while we're not a perfect team, almost no one else is, either. I do a lot of "stuff" in the stock market and with it a fair amount of trend following – trying to find situations where it seems like nothing much is going on, but underlying trends have turned favorable. With the Philiies I see on the surface a .500 club, but with the trends for Revere, Utley, M. Young and now Ruiz and D. Young being "up" – and D. Brown maintaining his high-level performance. I'm not a statistician but if all of that improving offense translates in the second half of the season to an additional 1 to 1.5 runs per game – and even with NO improvement in the pitching area – I'll bet the Phillies could play .600 ball. And that would mean 46-30 going forward, and an overall 87-75 … and that could mean playoffs.
Lou, I'm not a statistician either but I've seen this trend, while our team suffered losses and setbacks this first half, they somehow always managed to get on their feet ,get up, and avoid being disaster, aka the cellar. The way things are moving so far, the trends you mentioned, the second half looks good moving onto October.
Lefty, you are not alone. There's a whole nation of Phaithful Phillies Phans who stick with our team no matter what through all these years. After being there in 80 and 08 and all the years in between, It is UNIMAGINABLE to root for any other team.
Lou, you're right — the Pirates' lineup is no better than that of the Phillies, and it shows in their runs scored: Pirates 3.94 (11th), Phillies 3.88 (12th). Where the Pirates' position players are better is in the field, where they are one of the better defensive teams in the NL, while the Phillies are one of the worst.
But the big difference between the two teams is the pitching. The Pirates have the _lowest_ ERA in the NL, while the Phillies have the 3rd _highest_ ERA.
As for there still being a chance that the Phillies could contend, as Lefty says it's possible, but very much a long shot. It would be one of the more improbable comebacks in recent history. Stranger things have happened, and even the bullpen could somehow suddenly become one of the best in the league over the last 2-3 months, just as they did last year. But I certainly wouldn't bet anything of value on that comeback.
Just you and the Schmidt's in your hand.
Its good to have dreams – and Schreiber is spot on – in order for this club to contend, say win 90 games they would have to win 49 and lose 27. Seriously folks at this point haven't we seen where the leaves are falling yet? Winning nearly 2/3 or 66% of the remaining games?
Even with Young (both of them), Brown, Revere, Choochie (who may or may not hit a hr this year) and Utley batting close to their career averages – do you see Ryan Howard being able to turn it on? Accept it – the team may reach 80 to 84 wins but in my best Mora impersonation – "Playoffs?"
The whole they dug is too deep. "Wait until next year"
I'd just like to see them play solid baseball for a couple weeks straight.Every time they play a couple good games in a row, they seem to follow it with a couple garbage games.
That is all I am asking at this point too Tee – my expectations, hopes are just for some good ball the rest of the way. Hey, I have about 14 games left on my plans..
Is it a whole hole or half a hole?
IMO- The next seven games are the key to the season.
3 v the Braves, and 4 v the Nats, all at home. This is the head to head opportunity I've been talking about. These are the games that decide whether the Phils are a contender or a pretender. They also could be the games where they decide if they are buyers or sellers.
Can this pretty bad bullpen somehow hold up? Can the offense score enough runs that it doesn't matter how bad the pen is? Will the Starters keep us in these games for long enough? I think this is the week that we get many questions answered.
What could you possibly expect Lefty?
A sweep? 6 out of 7? Even 5 wins still gets them under .500 and probably 6 games out of first place.
Just hope for some decent baseball and some significant moves by the front office!
I hate to say it, but I think they have to sweep the Braves and win 3 out of 4 from the Nats. Doesn't seem possible, but we've seen stranger things happen. First order of business is win tonight, worry about tomorrow tomorrow. Howard always hits Hudson well, maybe he gets us started tonight.
a sweep of the braves puts us at 5.5 back and 3 of 4 vs the nats could bring us closer… I'd be real happy with that… then I say we're buyers and lets win this thing!!!
If these guys keep hitting then screw selling. Get some bullpen help.Let them play it out and see what happens.Go Phils!
MY prediction. They'll go 4-3 or 3-4. Just so poor RAJ won
t know if he should buy or sell.
Last year, we something like 37-50 at the break… Finished .500. It is very likely that this team will play much better in the second half. Now, I will admit that I'm very sentimental towards this team and will hold out hope longer than I should BUT I want to see this team get a chance to go for it one more time. We are 3 games into a 13 game death march- -13 games without a day off. If we can rifle off 9-10 wins, I'd say we have a good shot of putting some real pressure on the Braves. The key to this whole thing and the one guy that everyone counted on is/was Cole. He needs to be as good as he was tonight… If he can be that guy consistently, we might have enough. If we are trading Utley, I want nothing less than Zack Wheeler… That's what the Mets nabbed for Beltran. I want Amaro to be smart but don't sell short just to appease the masses.
chuck P, If Amaro was going to trade to appease the masses he already (last yr) would have been doing that and would have had Cholly making different lineups (Howard) out versus LH P's or batting 6th or below that. Howard not only can't hit LHs anymore but he clogs up the basepaths big time. Just to let you know I have been "Big piece" s biggest fans all these years and I know he hates what' s happening to his skills but he can't run, at all, has lost his power and can't hit to left against that shift cause if he did he'd be hitting .400. I'm sure a lot of these problems have to do with the achilles and now his knee but RAJ/Cholly need to admit its over for him with the P's and platoon him and not be afraid to pinch hit for him in critical game situations and for god sakes pinch run for him anytime in important situations. RAJ needs to figure out a way to get him to an AL team where he could be an DH. Yeah I know about his salary but if he has all the faults I mentioned for the sake of the team he needs to go and RAJ needs to eat whatever salary is necessary to make it happen.
Lord knows there's plenty to disagree with in Amaro's moves, but trying to appease the various whims of the masses would be a D I S A S T E R.
Shmenkman, for sure there's a whole lot more to a club's winning and losing than team batting average. But I've been exasperated – and what Phillies fan hasn't been – by our club's failure to win games not because of pitching shortcomings, but because of the club's inability to provide adequate run support. Hence my observation on recent trends, and my surmise as to how enhanced run support might favorably impact the Phillies, going forward.
My guesstimate that an added 1-to-1.5 runs per game could push this .500 club to a .600 win-loss record – all other things being equal and even forgetting about a Hamels turnaround – was strictly a wild-ass guess. I don't know if there are any stats on that particular subject; if anyone would know, you are certainly that guy. But since that .600 record would place us at 87-75 – a record good enough on many occasions to slip into the playoffs – I wouldn't categorize that result as "one of the more improbable comebacks in recent history." A few years back, the Diamondback went on some kind of ridiculous run over the last 20-or-so games to make the playoffs – that was improbable. What we did to the Mets a couple of years ago to overhaul them in the last week of the season – that was improbable. What we did to ourselves in 1964 over the last week of the season – that was improbable. And let's not forget that, in 1980, if my memory serves me correctly, over the first 107 games we were 55-52.
This is all to say that, IMHO, the odds of this particular version of the Phillies making the playoffs are not good. But the odds for a 87-75 scenario – even given the club's various shortcomings – really shouldn't be that long, and the more optimistic among us sense some positive rumblings afoot …
Lou, there's a fairly reliable formula for a team's total runs scored and runs allowed, and predicting how many games that team will win.
With, as you say, all else being equal, meaning the pitching is no better than it's been so far (terrible bullpen, mediocre Hamels, but also excellent Lee), the Phillies would need to increase their runs scored from the 3.9 per game they've averaged so far, to about 5.5 the rest of the way (an improvement of 1.6 per game) in order to win 60% of their games and finish with 87.
If the pitching does improve some, it would mean the offense can improve less, but the improvement needed in the run differential would remain about 1.6. So if they allow 4.0 instead of 4.4 the rest of the way (0.4 per game less), then the scoring would need to improve by only 1.2, from 3.9 to 5.1.
Now there's the element of how those runs are distributed across all the games, which evens out in the long run but wouldn't necessarily over 76 games. So by winning a lot of 1-run games, for example, (the kind they've been losing a lot of in very frustrating ways), then they wouldn't have to improve their run differential by quite that much.
*…formula for _taking_ a team's total runs scored and runs allowed, …
Thank you, Shmenkman, for giving some statistical structure to my WAG – which now doesn't seem quite so "WA", after all. I'd now say that if recent hitting trends are more than a head fake or flash in the pan … and Hamels has a second half reflective of his capabilities … and Lee remains Lee … then based on the info you've provided, the Phillies have a fair chance at 87-75, and a so-so chance of qualifying for the playoffs.


text:
12 May 2016
Dr Jenni Sidey Research Associate in Experimental Turbulent Combustion in the Energy, Fluid Mechanics and Turbomachinery Division.
09 May 2016
The James Dyson Building focuses on advances including smart infrastructure, electric vehicles and efficient internal combustion systems.
05 May 2016
Friction is immensely important to us yet it is only 50 years since a special word – 'tribology' – was first coined to describe its study.
29 Apr 2016
London is soon going to lose one of its most familiar sounds when the world-famous Big Ben falls silent for repairs.
28 Apr 2016
Professor Lord Mair, head of the Department of Engineering's Centre for Smart Infrastructure and Construction (CSIC), made his maiden speech to the House of Lords.
26 Apr 2016
We are saddened by the loss of Professor Sir David MacKay, who lost his battle against stomach cancer on Thursday 14th April 2016. He was 48 years old.
22 Apr 2016
How can we make voice interfaces with computers sound more natural?
18 Apr 2016
A new report from the University of Cambridge claims that British steel could be saved, if the industry is willing to transform itself.
15 Apr 2016
How can we make high-quality recycled steel?
13 Apr 2016
Biomedical Engineering brings together engineers and clinicians to improve clinical tools with engineering research, techniques and innovation to the field of clinical medicine.


text:
A safer fracking liquid?
Hoping to improve public opinion and address concerns from environmental groups about the process of hydraulic fracturing, those in the oil and gas industries are taking steps toward improving the liquids used in fracking.
The Associated Press reported that Halliburton, Inc., a Houston-based energy company, has introduced a product called CleanStim, which uses food-based products instead of typically hazardous biocides to break up bacteria that is susceptible to growing in underground wells.
"Looking at what I've seen so far, it is definitely an improvement over what they have been using," said Parkersburg resident Pavanne Pettigrew, who worked as a senior geologist with the West Virginia Department of Environmental Protection in Charleston for 17 years where she developed and administered the Underground Injection Control program for coal mining.
However, said Pettigrew, she would like to see the Material Safety Data Sheet (MSDS) for the product before throwing her full support behind the idea.
The MSDS is a legal document that lists all the materials in a given product and their hazardous potential, said Pettigrew. All products made or imported into the United States, including CleanStim, are required to have one.
Even without the MSDS, Pettigrew said she does not doubt Halliburton's claims that the ingredients are entirely food-based.
"You don't want to jump to too many conclusions there, though. Believe me, there are a lot of things we willingly eat that are technically hazardous," she said.
Halliburton will not be the only company striving to eliminate hazardous biocides entirely, said Jim Denny, president and chief operating officer for Triad Hunter, which is currently breaking ground on an injection well near Macksburg.
"We are even looking at going our own path to develop an all benign fluid," he said.
Halliburton's product is limited by certain factors, such as temperature and formations being fracked, said Denny, and therefore it was not a good fit for drilling operations overseen by Triad Hunter's parent company in Texas.
However, it is possible the product will be used locally. Testing at the new well will determine if it fits the bill for local Utica and Marcellus shale wells, he said.
Petroleum Development Corp. (PDC) Energy, a Denver-based company that also has wells in Washington, Morgan and Belmont Counties, did not return calls for comment Thursday.
The fact that companies are hearing and addressing public concerns is good news for local environmental groups.
"We feel very positive that they are trying to do research to make this whole process more safe," said Betsy Cook, a member of the Southeast Ohio Fracking Interest Group (SEOFIG).
Still, said Cook, there are concerns as to whether companies will embrace the new liquid.
"The main thing I see of course is that it is more expensive. Are companies going to use it?" she asked.
Denny said the cost is not the main concern of drilling companies.
"The impact on production is much more a consideration than the cost of the fluid," he said.
And even if the industry fully embraces nontoxic fluids, there are still concerns that the process of hydraulic fracturing triggers man-made tremors and eliminates large quantities of water from the water supply, said Pettigrew.
"This does seem to address that one problem, of what chemicals are being put into the ground, but it doesn't do a thing to alleviate possible earthquakes or address the usability of post-fracking waste," she said.


text:
Leopard Haircalf Clutch
Style: 570062977
Out of Stock
Chic as can be, this petite hard-sided clutch features our hand-designed leopard print on haircalf leather. Deco-inspired Lucite bar closure. Imported.
- Removable chain has lobster claw clasps; 11" drop.
- Silvertone metal frame.
- Black faille lining.
- Side gussets; hinged at the bottom.
- 8" L x 2" W x 3.25" H.
- Due to the inherent nature of haircalf, color variation may occur.
Read more… Read less…


text:
Gayle L. Troutman
Attention Lawyers - sign up here to join the directory.
A criminal charge is a legal charge against a defendant that committed a crime against another person or company, which is not covered under the civil code and that harmed the plaintiff in such a way as to make them a victim. Types of criminal charges include rape, murder, theft, assault, fraud and other felony charges. With criminal charges, the... Read more
We don't display the email address publicly, but this page will go to the organization's information that we have on file.
Attention Lawyers - sign up here to join the directory.
Legal Terms: # A B C D E F G H I J K L M N O P Q R S T U V W X Y Z
Home | Advertising Info | Write for Us | About | Contact Us
Copyright © 2016 Janalta Interactive Inc. - Terms of Use - Privacy Policy
Partner Sites : Techopedia |Divestopedia |Testopedia |Justipedia |Securities Institute |Safeopedia |Insuranceopedia


text:
For Immediate Release
March 21, 2011
27 Illinois School Districts recognized by College Board for increased participation on AP exams
More Illinois students taking rigorous, advanced courses
SPRINGFIELD — The Illinois State Board of Education joins the College Board in recognizing 27 Illinois School districts with making the AP Achievement List. The districts singled out for this honor either maintained or improved their participation and performance on the rigorous AP exams used toward college credit and placement. City of Chicago School District 299, the largest district in the state, also ranked as the largest district award winner.
"As we move to implement more rigorous learning standards in Illinois, this is a particularly important achievement for these 27 districts," said State Superintendent of Education Christopher A. Koch. "Many of these districts are not only providing more students with advanced academic courses but showing improved scores. Whether students are honing skills in science, math, a foreign language, history or other subject, they're pushing themselves beyond high school level work that will better prepare them for success in college and careers."
Overall, a record number of Illinois students are taking and passing AP exams, according to the sixth annual AP Report to the Nation. Illinois ranks in the upper half of the nation (18th) for the number of high school seniors who scored a 3 or higher on an AP exam.
Improvement in AP results typically requires sustained effort. The AP Achievement List is based on examination of three years of AP data, 2008 through 2010, from all students who took AP Examinations in May of those years. Districts must have met the following criteria to receive the award:
- Increased access to AP by
- At least 4 percent in large districts
- At least 7 percent in medium districts
- At least 11 percent in small districts
- The percentage of exams taken by African American, Hispanic/Latino, and American Indian/Alaska Native students must not be decreasing.
- Performance levels must be maintained or improved when comparing the percentage of exams scoring 3+ in 2010 to 2008.
While the AP Achievement List is not a roster of higher performing districts, it is a roster of districts that are simultaneously expanding opportunity and improving performance, so even low performing districts are included if they have been able to maintain or improve scores while expanding access. However, no district with less than 10 percent of AP Exams scoring 3 or better is included.
While performance levels must be maintained or improved among traditionally underserved minority students in order to qualify for the AP Achievement List, this criterion is waived for districts with less than five percent minority students so as to avoid penalizing small, rural districts that do not have significant racial/ethnic diversity within their high school populations.
The Illinois schools on the AP Achievement List for maintaining or improving participation and performance are:
Antioch Community High School District 117
Central Community Unit School District 301
Chicago Public Schools District 299
Diocese of Joliet Education Office
Edwardsville Community Unit School District 7
Elmhurst Community Unit School District 205
Elmwood Park Community Unit School District 401
Galesburg Community Unit School District 205
Grayslake High School District 127
Indian Prairie Community Unit School District 204
Joliet Township High School District 204
Lake Forest High School District 115
Lake Park Community High School District 108
Lincoln Way Community High School District 210
Maine Township High School District 207
Oswego Community Unit School District 308
Ridgewood High School District 234
Community Unit School District 300
St. Charles Community Unit School District 303
Thornton Township High School District 205
Township High School District 211
Township High School District 214
Triad Community School District 2
Urbana School District 116
Warren Township High School District 121
Wauconda Community School District 118
Zion Benton Township High School District 126


text:
Writers Workshop – Session 3
Join the Mill Valley Public Library in nurturing the creative spirit of our community. Aspiring and seasoned writers are invited to join a session of the third session of Mill Valley Writers Workshop. Members will have the chance to meet other writers, write, and share feedback, all under the guidance of two talented moderators--Caitlin Myer and Peg Alford Purcell. This session will culminate with a public reading and live writing session.
Session 3 will consist of the following dates: October 22nd, November 5th, November 19th, and December 3rd
Time: 7PM -9PM at the Library.
Culminating Performance date TBD in the Creekside Room.
Click here for more info and to register.
© 2016 Mill Valley Public Library | 375 Throckmorton Ave | Mill Valley, CA 94941 | (415) 389-4292
Contact the Library | Privacy Policy & Disclaimer | Website developed by Vision Internet


text:
"I have been a fan of Catholic Answers from its beginnings. Keep up this great apostolate, as it does help many of our Catholics appreciate their faith, especially in the military. Blessings and prayers for your continued success."
"In order to restore in the world the reign of Jesus Christ, nothing is as necessary as the holiness of the clergy."


text:
We can beat these guys....Go Knicks
Date: November 27, 2010
Time 1:00 PM
Madison Square Garden
Atlanta Hawks - (8-4)
AT GUARD Raymond Felton #2
AT GUARD Landry Fields #6
AT Foward Amare Stoudemire #1
AT Center Ronny Turiaf #14
ESPN.com Preview
The [Only registered and activated users can see links. ] haven't defeated a team with a winning record during their current run. They get a chance to change that when they face an [Only registered and activated users can see links. ] club that hasn't beaten an opponent over .500 this season.
The Knicks look to win six straight for the first time in nearly five years when they host the Hawks on Saturday.
New York's five consecutive victories have come against teams that are a combined 19-41 heading into Friday's games.
The Knicks (8-8) finished a home-and-home sweep of Charlotte with a 99-95 road win Wednesday. New York's last six-game winning streak was from Jan. 2-13, 2006.
"Winning five straight feels great," said forward [Only registered and activated users can see links. ], averaging 25.8 points with 8.6 rebounds and 3.0 blocks during the streak. "But being 8-8 and .500 is something that we've got to improve on. We still have a lot of work to do."
The Knicks may want to start at the defensive end. Despite leading the league with 7.9 blocks per game -- 4.2 more than last season, when it was last in the NBA -- New York is giving up 107.1 points per game on 47.8 percent shooting.
The Knicks, 2-4 at Madison Square Garden, will face a Hawks team that has a Eastern Conference-best 5-2 road record. Atlanta's 104.0-point average in road contests is among the highest in the league.
Coach Larry Drew's club is shooting 49.3 percent from the field and 39.6 percent from 3-point range away from Atlanta.
The Hawks (9-7) snapped a three-game slide with a 116-96 win over Washington on Thursday. The victory was Atlanta's most lopsided of 2010-11.
"We hadn't had a game like this all season," forward [Only registered and activated users can see links. ] said after scoring 20 points with a season-best 14 rebounds and two blocks. "We have to make a statement every time we play a division team. We just have to get wins at this point."
The Hawks also need leading scorer [Only registered and activated users can see links. ] to continue to shoot better. The four-time All-Star went 8 for 16 and scored a team-high 21 points Thursday, but averaged 12.2 on 31.8 percent shooting in the previous five games.
Johnson scored 24.5 points per game with 6.8 rebounds and 5.8 assists as Atlanta lost three of four to New York last season.
The Knicks have been getting strong play out of point guard [Only registered and activated users can see links. ], who had 23 points with a season-best 13 assists against his former teammates Wednesday. Felton is averaging career highs of 17.8 points and 8.0 assists in his first season with New York.
Coming off his ninth double-double with 15 points and 13 boards, [Only registered and activated users can see links. ] will look for another big game against the Knicks. He has averaged 18.0 points and 11.0 rebounds in five career games in New York, though his last one there ended in disappointment.
On March 8, Horford's short jumper was waved off after replays showed it came after the final buzzer in a 99-98 loss.
[Only registered and activated users can see links. ] scored a game-high 27 points in that matchup for the Knicks, winners of 19 of 25 against the Hawks at MSG.Unofficial JPZ Game Thread (Just slakin' off here)
We can beat these guys....Go Knicks
Can't wait. Love every matchup. Statement game.
I'll be sleeping. Gonna watch on the DVR soon after I wake up.
Go Knicks!
Sig made by Sons of Thunder
fantastic for me here in England. Tip off is 1pm your time so 6pm my time. finally I get to see a Knicks game live on my league pass. i usually have to wait until the next morning to watch the games.
This is a huge game in my opinion. Our winning streak has come against teams that we should be beating. This game will give us a better idea of where we are in developing our new look team. Defence is a must which frightens me because we all konw that our stupid coach is a no-d coach.
I think the game will be tight but we will win, hopefully with Gallo taking over the fourth quarter as he has done more recently.
Got a bad feeling about this one boys.
Felton needs to take the reigns and put his stamp on this game as he has been.
I like Fields on JJ. He better bring his hardhat and D up.
Hope my gut is wrong..
The Hawks are a really good athletic team. If there is one team we aren't built to run against, it's this one. This game will be interesting to watch.
Originally Posted by Knicksin60
Real test to see where this team is standing today. If we win we're tied for 5th with atlanta. Pretty evenly matched team. This should be fun
Orange and blue, yesterday, today, and tomorrow...
As much as the knicks need this win, and I want them to win, I don't think they will. It's been too many days since their last game. The knicks play off energy of the last game, thats why they go on win streaks and losing streaks back to back.
Landry almost has a set shot. There's a mechanical advantage to it as less can go wrong.
Gallo posting and passing out of the post = good money.
im at work anybody here knows where i can watch this game online?
We actually look pretty good. Still liked our cjances even when behind 15. Had more to do with them playing like God and Josh Smith hitting jumpers like Kobe.


text:
Rolling in my Mix - RC Week 156
Your original file link
I am really amazzed how much you have improved your mixing since the day i heard your first mix. This mix is whole story and i love it from the start to the end! Amazzing work, Munna!
i am happy to receive this comments jasmina i am trying to make more better transitions for further weeks
Awesome mix by u Sri bro great work i love it
wow! sounds sooooooo awesome!!!! I appreciate your progress! Didnt know they have songs in the russian language too But anyway .. it sounds awesome... I really enjoyed it!
wow...great work munna bro..... and great track selections..... love ur remix.....
amazing mix superb tracks great mixing awsome transitioning and love the ending impressive job by you
Great rocking mix Full of energy
Munna my favorite like every week you also try you level best this week and most of all made it with your heart that's amazing
clap for you love everything in it
You have done an cool job bro
gr8 entry ... Awesome mix.. well done
ROCKING Rmx bro sounds super awesome perfect work with mixing and i am loving your mix well done keep them crazzy mixes coming...
Excellent rocking mix bro
It sounds perfect..i can't stop listening to itgreat song selection & very well mixedvery well done..i love it so much
Thats an awesome rock n roll mix by you Sri bro
Superb tracks chosen and impressively mixed
Love it very much Well done
very very cool rock n roll mixing munna bro..
i enjoyed alot
love the track and great mixing..
cool ending too.
love it so much...
Great work munna !! Fantastic mixing bro, keep it up !!
Nicely Done.. Cool Mix...
That's a great rock and roll mix Sri bro
Great mixing
Sound great
Love this tune
love the music SRI(as per srict instructions from u)...
really Awesome mix
Hey your composer sounds great
i liked it
Such an awesome remix Sounds more than great Wonderful transitions Great job Love it to the max


text:
Let's see -
The only 2 parts that wouldn't be universal would be the chest and the cod piece . Problem is - Would the average laymen want to have a heavy chest piece made of Resin , fiberglass , and Bondo to wear around? With all of the bondo work on a piece as big as the chest, I imagine it could get rather heavy . I'll have to think that one through . As for everyone getting casts of every piece , How about they all get a cast of just the universal pieces? Any thoughts? Input please!
Your best bet is to avoid molding and casting any of the parts, just go with the original parts, this way you know there is a good chance you will finish this project before the deadline, anything you add extra to the build such as molding will only prolong the build, also remember most cast copies have casting flaws that will have to be fixed up also, so you would have to do work on the casts just to prep them for paint, but Jacob your basically the one in charge of the project so ultimately you will have to make the final decision, I wouldnt stress it much just put a plan in place and go with it and get this project rolling..............Good Luck guys can't wait to see this build come together and see a community build
This is MY understanding of a "universal part:"
Now for some examples to help everybody understand.
To show the difference between universal parts and ones that are different on each side, we'll use the pepped shins and gauntlets from my ODST build because they're similar to the H4 parts i'm corresponding them to.
The shin is a universal piece. that is because it can be worn correctly on either side of the body without any modification. See?
If I were to make a mold of this shin, I could make two casts from it, and one could be used on my right leg, the other for my left.
Now the forearms on the other hand are NOT universal. This is because they CAN NOT be worn correctly on either side without modification. See?
If we were to mold this, we could only use it for one side.
I hate to sound like an ass, but I just want to make sure everybody understands this correctly.
Last edited by higdog827; Mar 22, 2012 at 11:05 PM.
Jacob I swear I'm not trying to poke holes in your thought bubble or pile more issues on top of current ones, just mentioning this cause it's stuff valid to the build.
Last edited by higdog827; Mar 23, 2012 at 12:17 AM.
Ok so - The non-universal parts are -
The Helmet
the chest
the forearms
the cod piece
and the thighs
That means the only universal parts are -
The handplates
the shoulders
the knees and shins
and the boots
My concern is weight . I'm thinking of the person who is going to end up with this suit . Will they really want to wear around a suit where the main bulk of it is going to have a serious amount of heft too it?
That is why I wanted everything to be molded and cast out . Because that is not the case anymore , everyone here must make a effort to make your piece as light as possible . This was also a concern last year , so we used smooth-cast 300 to harden the inside of the helmet . It worked beautifully ! Here is a video that Jedistumpy made a few years ago -
and the results of it
I think the pieces such as the chest should be hardened this way . A layer of fiberglass resin on the outside , smooth-cast on the inside (sounds like a pillsbury commercial lol)
That being said , the helmet will still be molded . No one wants fiberglass in their face lol
As far as a deadline , there isn't one . I think we should just focus on making this suit awesome and taking our time . And @SeniorRawr - No bubbles poked
Last edited by JBetts97; Mar 23, 2012 at 12:01 PM.
Jbett, do you want me to tackle the guantlets? you never responded to my PM with questions. lol
jacob, look closely at the model toy's shin pieces, they arent the same on inside and outside
That is just a toy. A representation. A prototype. If you compare the toy to the game footage the index finger is different. I'm trying my hardest not to look at the toy for references. In the end It depends on the modeler, if they decide that it looks the same inside and out that they make it that way. And even then it's your decision to make it from their model or make your own.
Hey guys i dont have any updates for you guys yet, but i did just now ordered some sintra and styrene so, ill be starting the BR as soon as the stuff arrives! (:
As promised , Here is a picture of the new Halo 4 print that everyone who works on the project and donates too it will receive !
they have a large variety of sizes and even colors, white being the best lol
Last edited by JBetts97; Mar 30, 2012 at 9:25 PM.
Also, i just downloaded the thigh piece pep from kingrahl (amazing job on those file by the way!), so expect updated next week probably. I cant wait to get started!
Last edited by higdog827; Mar 27, 2012 at 5:05 PM.
After a couple of people suggesting that the picture be darkened , here is the new and final drawing! Everyone who contributes in some way , shape , or form will receive a print of this! Hope you like it!
here is a comparison between the old and new
Last edited by JBetts97; Mar 30, 2012 at 9:23 PM.
Wow that looks fabulous!!


text:
Goliad junior utility player JJ Stastny and junior second baseman Ryder Billo were chosen to the second team and Joseph Lujan earned honorable mention.
Billo, Heibel, Davis Ohrt, Denton Ohrt, Zachary Helmer and Justin Thomas were named to the academic all-district team.
Refugio's Travis Quintanilla was selected Most Valuable Player, Palacios' Zach Garcia was named Offensive Player of the Year, Refugio's Tyler Castellano was chosen Defensive Player of the Year, Edna's Landon Myers was selected Newcomer of the Year and Refugio's Armando Huerta was named Coach of the Year.
Other first-team members were Aransas Pass pitcher Victor Gonzales, Edna pitcher Dequan Cantu, Industrial pitcher Will Maraggia, Palacios pitcher Drake Garcia, Refugio first baseman Colton Carroll, Palacios second baseman Jonah Solis, Refugio second baseman Cameron Sternadel, Aransas Pass third baseman Matt Johnson, Edna Ross Novian, Aransas Pass shortstop Hunter McElroy, Edna outfielder TJ Foley, Palacios outfielder Dylan Brune, Refugio outfielder JW Shipp, Refugio designated hitter Cameron Loverday and Industrial utility player Brandon Maraggia.
Other second-team selections were Palacios pitcher Chris Deleon, Refugio pitcher Cole VanNess, Tidehaven pitcher Brandon Litzau, Aransas Pass pitcher Jordan Cole, Refugio catcher Shane Jochetz, Palacios first baseman Garret Shimek, Palacios third baseman Seth Garcia, Refugio third baseman Draigon Silvas, Tidehaven shortstop Cameron Sides, Bloomington shortstop Javier Reyes, Palacios outfielder Joseph Rodriguez, Refugio outfielder Jim Lafond, Industrial outfielder Kevin Gibbs, Bloomington outfielder Josh Cantu, Edna outfielder Billy Ganem, Tidehaven designated hitter Isaac Ibarra and Tidehaven utility player Eric Villarreal.


text:
Household items you're paying too much for
Published On: Mar 26 2013 06:33:16 AM PDT Updated On: Mar 22 2016 09:05:06 AM PDT
Find out which household items you could be saving money on.
The views expressed are not those of this company or its affiliated companies. By posting your comments you agree to our Terms of Use.


text:
Sorry, no content matched your criteria.
WFD | World Federation of the Deaf
World Federation of the Deaf, WFD, human rights, deaf, deaf people
Sorry, no content matched your criteria.
An Individual Member of the WFD contributes to organisation's daily work which deals with supporting and strengthening deaf associations, organizing human rights trainings, advancing deaf people's rights in the United Nations human rights system, spreading information on the Convention on the rights of persons with disabilities(CRPD), producing material in sign language and much more.


text:
You are here: Home
/ KYF Compass - Case Studies OKF2S
Good Growing in Oklahoma, Year Round
A sweet, juicy watermelon is the perfect snack to dig into on a hot summer day. Even more perfect is bringing home a fresh one from a local farmers market or farm stand. What if you could have that same sweet experience when school starts, and have it delivered fresh from the farm to your school cafeteria?
That is just what students are experiencing in Oklahoma.
Hoop houses, also known as high tunnels, are temporary greenhouses that allow farmers across the state to supply Oklahoma's Farm to School Program with fresh, local products from the start of classes in August to the final bell in June.
"With the use of hoop houses, more farmers can grow in the fall, throughout winter, and into early spring to provide wonderful food in our schools year round," said Chris Kirby, Farm to School Program Administrator for the Oklahoma Department of Agriculture, Food and Forestry.
To keep these kinds of opportunities growing throughout the state, Kirby works to connect farmers with needed resources. USDA's Natural Resources Conservation Service has a Seasonal High Tunnel Initiative that provides cost-sharing for hoop houses. "If we provide economic opportunities to the farmers, we can get the food to schools," said Kirby.
In late winter and early spring, when it is too cold for outdoor planting, hoop houses allow garden-fresh favorites to flourish. Students in Oklahoma might enjoy fresh greens at the salad bar for lunch in February, root vegetables at snack time in March and even tomatoes before school is out.
Under Kirby's leadership, efforts to increase season extension through hoop houses are bringing these foods and more to Oklahoma's Farm to School Program (OKF2S), and new marketing opportunities to local growers. OKF2S provides workshops, resources, and even hoop house construction drawings for growers of all types to learn about extending their season.
Steve Hill of Phocas Farms in Edmond, OK is one of the producers now able to produce fresh, healthy food year round, even in the winter, thanks to a hoop house. He recently started selling his products to Edmond schools. And he's seen that hoop houses are not only beneficial for the cafeteria, but the classroom too.
During the school year, high school students in Oklahoma take field trips to farms like the Hill's, where they learn about agricultural production, nutrition, and business education. Five AP environmental science classes from Edmond North High School visited Phocas Farms this fall to learn about organic growing practices, see where some of their food is produced and get hands-on experience with field and hoop house production. They'll connect what they're learning to science, math and other courses.
Through these and many other efforts, Kirby and OKF2S are helping create new sales opportunities for Oklahoma farmers and expanding access to fresh, healthy, local food in schools. Interest is overwhelming: there are currently over 70 school districts participating in OKF2S. Let the growing continue!
For more examples of how USDA supports direct connections between local producers and local schools, and for information on season extension, read the Farm to Institution Chapter of the Know Your Farmer, Know Your Food Compass. Search "farm to school" and "hoop house" or "high tunnel" on the Compass map to find similar projects in your area.