Tweet Old Post is no more tweet old post because you can even post your latest tweets with tweet old post now. Tweet old post was designed initially to tweet your old post. But the changes made to tweet old post will also allow you to tweet your latest post, thus not only keeping your old post alive but also, promoting your new posts.

New in Tweet Old Post v 3.0

OAuth

Added OAuth authentication. You just have to click on the signin button and login to your twitter account to associate it with Tweet Old Post to which tweets are to be posted. If successful it will show you your avatar and give you option to DeAuthorize.

If you want to remove the association between your twitter account and Tweet Old Post plugin you'll have to DeAuthorize your twitter account from Tweet Old Post plugin. You can then associate another account with Tweet Old Post.

Minimal Interval Between Tweets

You need to enter Numeric value. This value is Interval between two tweets. This value is in hours. It has to be minimum 1 for your tweets to be posted.

Random Interval

This is a contributing factor in minimum interval so that posts are randomly chosen and tweeted from your blog. This value should be Numeric. This value is in hours and should be minimum 1 for your tweets to be posted.

Minimum age of post to be eligible for tweet

This is minimum age of your post to be available for tweet. This value is in day / days

If you set it for 10 days all your post older than 10 days become and are eligible for tweet, and one of them will be randomly picked and tweeted. Any of your post which is published in last 10 days will not be tweeted.

If you want your latest / today posts to be tweeted you can set this value to 0 day. 0 day means the post which you just published will also be eligible for tweet and will be considered while tweeting by tweet old post.

Maximum age of post to be eligible for tweet

This is maximum age of your post to be available for tweet. This value is in day / days

If you set it for 20 days all your post older than 20 days are not eligible for tweet, and will not be tweeted.

if you want to tweet your latest post of today and day before, you can set minimum age to 0 day and maximum to 1 day.

If you want to tweet your posts of last 10 days, you can set minimum age to 0 and maximum age to 10.

If you have more ideas or suggestions about Tweet Old Post feel free to drop a comment or mail me. Looking forward for your replies

But, I have got a very big question to ask, “are these framework making the life of Developer really easy?”

With the increase in the speed and number of the javascript framework, its getting difficult for the developers to decide which framework is to be used where.

Here, http://mootools.net/slickspeed/, you can test the speed/validity selector test for some of the major frameworks available.

You can get comparison matrix for most of the Javascript framework here,

http://en.wikipedia.org/wiki/Comparison_of_JavaScript_frameworks

The following guidelines might help you to decide which framework you should go for,

What are your project requirements?

The first and most important question you need to ask yourself is what are your project requirements? Is this a Web site or application that requires AJAX, robust support for handling events, or how about a library of effects? How much functionality do you need out-of-the-box, and what level of experience will be required by other programmers and designers to support this framework? If you have few requirements, you could find success with an extremely lightweight, modular library. Also you need check if your project requires effects, AJAX, graphics, tools etc

Does the framework supports all the browsers?

Once you know your audience, and your project requirements, you need to consider whether or not your JavaScript framework supports all the needed browsers. Most frameworks do, but there are often some exceptions in the fine print — typically with Safari on the Mac. If you are building an internal Web application for an Intranet, you might only be required to support a limited set of browsers.

How mature is the framework?

More than anything, the maturity of a framework demonstrates a commitment to longevity, as well as a solid foundation. A mature framework will no longer be in beta, and will have been through a full release cycle. There should be a growing, if not thriving community, and depending on the open-source license, a mature framework might also support a Subversion or CVS version repository. Any bug fixes can be rolled into a build without a public release, which is a huge plus.

How often are updates publicly released?

If you find that the community questions or complains about the release cycle, then that could be a warning sign. Long delays and bloated releases are also a sure sign that you will not enjoy supporting the framework on future projects. Alternatively, too many public releases could indicate instability, or a lack of focus.

How friendly is the documentation?

A major differentiators between JavaScript frameworks today is documentation. This not only includes official documentation for the API, but also includes books, tutorials, and blogs. The worst documentation is the sort that is only focused on syntax. Look for a framework that includes examples with each method and property, and that is updated to meet the needs of the community. Documentation is simple to research, and it can be a lifesaver when dealing with tight deadlines.

Is there an active community?

An active community does not guarantee a quality framework, but it does help a framework evolve. The character of the community is also an excellent gage of the type of help you might receive in the future when caught in a bind. Are there forums, or a Google Group? Are experienced users willing and able to lend a helping hand, or will they send you elsewhere for assistance? Are developers creating extensions, or contributing to the core framework? All of these are important questions.

Are benchmark tests performed regularly?

Benchmark tests are often questionable when determining the quality of workmanship put into a framework, but they do demonstrate a developer’s willingness to adopt some quality assurance best practices. Even a modest gain in speed, or a decrease in download size during a release cycle can be seen as a positive improvement.

How extensible is the framework?

Extensibility is typically a requirement of experienced programmers, and is rarely a request of designers. Plugin support is definitely a plus for any JavaScript framework, but developers usually just want to know — how difficult will it be to troubleshoot the core library? Layers of functionality provided by an active community do give a framework uniqueness, but this is a beneficial byproduct, and not often a necessity.

Do you like the API style?

This is an important, but complicated question that is answered for most developers only after using several JavaScript frameworks on numerous projects. Complaints about frameworks like Yahoo! UI are generally in regards to the style with which the API has been designed. Terseness, as well as chainability, are two very important features that should not be overlooked. Remember, you can grow irritated quickly because of cumbersome implementation details.

1. Download http://downloads.zend.com/pdt/server-debugger/ZendDebugger-5.2.12-cygwin_nt-i386.zip or check for new version at http://downloads.zend.com/pdt/server-debugger/

2. Locate ZendDebugger.so or ZendDebugger.dll file that is compiled for the
correct version of PHP (4.3.x, 4.4.x, 5.0.x, 5.1.x, 5.2.x) in the
appropriate directory.

Get debugger from folder called “5_2_x_comp” or you may receive some errors about a non-thread   safe debugger if you take it from “5_2_x_nts_comp”

3. Configure php.ini for output buffering when debugging

implicit_flush = On ; Default: Off
output_buffering = Off ; Default: 4096

4. Add the following line to the php.ini file:
Linux and Mac OS X:     zend_extension=/full/path/to/ZendDebugger.so
Windows:                zend_extension_ts=/full/path/to/ZendDebugger.dll
Windows non-tread safe: zend_extension=/full/path/to/ZendDebugger.dll

(*) the windows non-thread safe is used only with Zend Core 2.0

Note:
if you don’t have a Zend section you may add this at the end of the fie.
correct the php path if it is not installed in c:\wamp\www and extension directory.

5. Add the following lines to the php.ini file:
zend_debugger.allow_hosts=<ip_addresses>
zend_debugger.expose_remotely=always

This willl allow connections from local host and from your local network to addresses which start        with 192.168.1.

6. Place dummy.php file in the document root directory.

7. Restart web(Apache/Wamp) server.

8. To activate the debugger please use following query string:
?start_debug=1&debug_port=10000&debug_fastfile=1&debug_host=192.168.1.59%2C127.0.0.1

Note:
above statement assumes that the debugger listens at 192.168.0.2 or 127.0.0.1 on port 10000.

Here are some of the screen shots from my debugger,

Breakpoint in Zend

This is watch window in Zend which will show the values of the variables, you need to add the variable to the watch window to view its values.

Watch Window in Zend

This is the output window that shows the output generated by the code executed till now,

Output Window in Zend

Hope this helps

All you need to install Sharepoint, WSS or MOSS, on Vista is

• You must select the Advanced option during install.
• If you want to run on SQLExpress, manually install it first.  Get it here.
• You have to manually enable IIS7 with the proper options. Web Management Tools and World Wide Web Services. Enable at least the following options in IIS.

Download Vista Helper file from here, and run the setup file WssVista.msi.

Sharepoint on Vista

You will see an UAC prompt select Continue to proceed with the installation.

Once the install has completed you will find the SetupLauncher.exe in the install location you selected. If you didn’t change the default option you will see it under the directory ..\Program Files\WssOnVista\

Sharepoint on Vista

Before starting the setup make sure you have enabled IIS with the following options, Web Management Tools and World Wide Web Services. Enable at least the following options and choose OK.

To set this Go to Control Panel and click Programs. Under Program and Features click Turn Windows features on or off.

Sharepoint on Vista

After completing the above steps it’s time for the interesting part. Locate SetupLauncher.exe and start it. You will once again see an UAC prompt, select Continue.

Sharepoint on Vista

After the SetupLauncher run, select the WSS installation file Sharepoint.exe, or the MOSS installation file, and click OK.  First, the package will be extracted.

Sharepoint on Vista

After the files have been extracted the WSS setup program will be started.

Sharepoint on Vista

The current version only supports the advanced installation option so select that one.

Sit back and relax while SharePoint is being installed, you are running Vista remember

Once installed you can configure your Sharepoint setup.

Sharepoint on Vista

Let the Configuration Wizard do it’s work.

Sharepoint on Vista

The final result is WSS running on Vista, Enjoy!

Sharepoint on Vista

Resource:

Bamboo Solutions

You can find more on their forums. Enjoy!!!

No. 2: Ability to create a vision
To lead, you have to identify your target and create a vision for your staff of where you want to be. To lead, you have to take charge and point the team to the desired destination. Managers who can develop and articulate a vision to their staff can accomplish great things because people will follow them. Communicating a vision tells
those around you that there is focus and that you are committed to take the organization to a specific destination.

No. 3: Ability to create the plan
Once they know where they want to be, successful managers know how to develop a plan that will get them there. That means choosing the right priorities for the situation and developing plans that are aggressive but achievable. Planning is an essential ingredient for a “high achiever” manager, but too many managers fail to plan. Instead, they react, accomplishing much less than what the organization is capable of. Having the ability to develop a plan that addresses company goals and objectives positions you for more responsibility. Planning denotes a sense of being proactive vs. reactive.

No. 4: Ability to build the team
Successful managers know the importance of building a team that has depth as well as skill in critical areas. A successful manager must know how to improve an existing team, as well as how to build a new one from scratch. Every good manager I’ve seen has the ability to build the right team for the issues at hand and can anticipate what will be needed in the future so that the team is prepared for new challenges. Strong career managers are effective career builders of people. They understand the importance of career and use career building as a tool to develop a stronger team capable of operating more independently.

No. 5: Ability to focus the resources
Focusing IT staff, money, and technology resources on key priorities of the company is essential to achieving success. The technology resources must be focused on initiatives that are in sync with company needs and objectives, and they must deliver in a productive, cost-effective manner. Career-minded people at any level understand the need for strong focus.

No. 6: Ability to implement a “client service” mindset
A high level of client service is essential for any IT organization. Successful managers create a culture that places customer issues first-whether the customers are internal users or external clients. Great IT managers know the reason they have careers is because people need the technology and support services that they provide, which is why successful IT managers build excellent client relationships.

No. 7: Ability to manage projects
The cornerstone of any IT manager’s job is that the organization can deliver project initiatives in a predictable and cost-effective manner. Effective project management discipline must be a key part of any manager who expects to succeed. Regardless of your career direction, strong project management skills will enhance your opportunities.

No. 8: Ability to implement change management processes
Technology, by its nature, demands rapid change. Every IT manager needs to be able to understand how to effectively implement change, whether it’s swapping out a PC, upgrading an entire network, or developing and installing new software. Failure to manage change effectively will cripple any manager.

No. 9: Ability to lead and motivate
IT organizations don’t get a lot done unless they are motivated. IT managers who can create significant momentum by virtue of strong leadership and motivation techniques always achieve more than those who can’t. Getting things done through others is a key skill required for management success.

No. 10: Ability to communicate effectively
Successful managers can communicate on many different levels with all types of people. More than ever, career success is highly dependent upon effective communication skills. Getting your message across to technical staff as well as nontechnical clients, being able to manage expectations effectively, and “netting out” issues and project status with senior managers are necessary skills that prevent many managers from achieving high levels of success. IT managers who achieve the greatest career success are those who can communicate effectively with all levels of people: employees, peers, internal and external clients, vendors, and senior management.

No. 11: Ability to track and measure performance
It’s important to set objectives and be able to measure your progress. Successful managers establish specific measurements that tell them and others how well the organization is doing and provide feedback that helps
managers “zero in” on issues that will improve the organization’s performance.

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 are project converter that helps you to convert the project. Here is converter for C# projects and here is for VB projects.  The program can be launched as a normal windows application or it can be installed in order to get a new Explorer “shell extension” that adds ProjectConverter to the “Open With” option when right-clicking on a *.sln file.

The solution file is a text-based file that contains information about one or more projects.  The solution file contains the target version of Visual Studio. You can change this version number to change the target Visual Studio Version, from higher to lower.

Here is how the solution file looks like,

Microsoft Visual Studio Solution File, Format Version 10.00
# Visual Studio 2008
Project(“{F184B08F-C81C-45F6-A57F-5ABD9991F28F}”) = “ProjectConverter”,
“ProjectConverter.vbproj”, “{B637ACFD-0AFC-4FBB-A8C0-602B5ABA62F0}”
EndProject
Project(“{54435603-DBB4-11D2-8724-00A0C9A8B90C}”) = “Setup”, “SetupSetup.vdproj”,
“{09667F41-0E35-4D40-A0A9-E71BA6740D93}”
EndProject
Global
  GlobalSection(SolutionConfigurationPlatforms) = preSolution
    Debug|Any CPU = Debug|Any CPU
    Release|Any CPU = Release|Any CPU
  EndGlobalSection
  GlobalSection(ProjectConfigurationPlatforms) = postSolution
    {B637ACFD-0AFC-4FBB-A8C0-602B5ABA62F0}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
    {B637ACFD-0AFC-4FBB-A8C0-602B5ABA62F0}.Debug|Any CPU.Build.0 = Debug|Any CPU
    {B637ACFD-0AFC-4FBB-A8C0-602B5ABA62F0}.Release|Any CPU.ActiveCfg = Release|Any CPU
    {B637ACFD-0AFC-4FBB-A8C0-602B5ABA62F0}.Release|Any CPU.Build.0 =Release|Any CPU
    {09667F41-0E35-4D40-A0A9-E71BA6740D93}.Debug|Any CPU.ActiveCfg = Debug
    {09667F41-0E35-4D40-A0A9-E71BA6740D93}.Release|Any CPU.ActiveCfg = Release
  EndGlobalSection
  GlobalSection(SolutionProperties) = preSolution
    HideSolutionNode = FALSE
  EndGlobalSection
EndGlobal

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 ProjectSection 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 HacksLib 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.

The difference between the product version and the file format are displayed here,

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. the Build section, which includes build settings and configuration settings as well as references information.  The project file will usually contain at least a Debug and Release section.

The 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.

Similarly projects .vbproj or .csproj is XML format file which looks like this,

<?xml version="1.0" encoding="utf-8"?>
<Project ToolsVersion="3.5" DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
  <PropertyGroup>
    <Configuration Condition=" '$(Configuration)' == '' ">Debug</Configuration>
    <Platform Condition=" '$(Platform)' == '' ">AnyCPU</Platform>
    <ProductVersion>9.0.21022</ProductVersion>
    <SchemaVersion>2.0</SchemaVersion>
    <ProjectGuid>{B637ACFD-0AFC-4FBB-A8C0-602B5ABA62F0}</ProjectGuid>
    <OutputType>WinExe</OutputType>
    <StartupObject>ProjectConverter.My.MyApplication</StartupObject>
    <RootNamespace>ProjectConverter</RootNamespace>
    <AssemblyName>ProjectConverter</AssemblyName>
    <FileAlignment>512</FileAlignment>
    <MyType>WindowsForms</MyType>
    <TargetFrameworkVersion>v2.0</TargetFrameworkVersion>
    <OptionExplicit>On</OptionExplicit>
    <OptionCompare>Binary</OptionCompare>
    <OptionStrict>Off</OptionStrict>
    <OptionInfer>On</OptionInfer>
    <ApplicationIcon>Icon1.ico</ApplicationIcon>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Debug|AnyCPU' ">
    <DebugSymbols>true</DebugSymbols>
    <DebugType>full</DebugType>
    <DefineDebug>true</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <OutputPath>binDebug</OutputPath>
    <DocumentationFile>
    </DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
    <DebugType>pdbonly</DebugType>
    <DefineDebug>false</DefineDebug>
    <DefineTrace>true</DefineTrace>
    <Optimize>true</Optimize>
    <OutputPath>binRelease</OutputPath>
    <DocumentationFile>
    </DocumentationFile>
    <NoWarn>42016,41999,42017,42018,42019,42032,42036,42020,42021,42022</NoWarn>
  </PropertyGroup>
  <ItemGroup>
    <Reference Include="System" />
    <Reference Include="System.Data" />
    <Reference Include="System.Deployment" />
    <Reference Include="System.Drawing" />
    <Reference Include="System.Windows.Forms" />
    <Reference Include="System.Xml" />
  </ItemGroup>
  <ItemGroup>
    <Import Include="Microsoft.VisualBasic" />
    <Import Include="System" />
    <Import Include="System.Collections" />
    <Import Include="System.Collections.Generic" />
    <Import Include="System.Data" />
    <Import Include="System.Drawing" />
    <Import Include="System.Diagnostics" />
    <Import Include="System.Windows.Forms" />
  </ItemGroup>
  <ItemGroup>
    <Compile Include="fmMain.vb">
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="fmMain.Designer.vb">
      <DependentUpon>fmMain.vb</DependentUpon>
      <SubType>Form</SubType>
    </Compile>
    <Compile Include="My ProjectAssemblyInfo.vb" />
    <Compile Include="My ProjectApplication.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Application.myapp</DependentUpon>
    </Compile>
    <Compile Include="My ProjectResources.Designer.vb">
      <AutoGen>True</AutoGen>
      <DesignTime>True</DesignTime>
      <DependentUpon>Resources.resx</DependentUpon>
    </Compile>
    <Compile Include="My ProjectSettings.Designer.vb">
      <AutoGen>True</AutoGen>
      <DependentUpon>Settings.settings</DependentUpon>
      <DesignTimeSharedInput>True</DesignTimeSharedInput>
    </Compile>
  </ItemGroup>
  <ItemGroup>
    <EmbeddedResource Include="fmMain.resx">
      <DependentUpon>fmMain.vb</DependentUpon>
      <SubType>Designer</SubType>
    </EmbeddedResource>
    <EmbeddedResource Include="My ProjectResources.resx">
      <Generator>VbMyResourcesResXFileCodeGenerator</Generator>
      <LastGenOutput>Resources.Designer.vb</LastGenOutput>
      <CustomToolNamespace>My.Resources</CustomToolNamespace>
      <SubType>Designer</SubType>
    </EmbeddedResource>
  </ItemGroup>
  <ItemGroup>
    <None Include="app.config" />
    <None Include="My ProjectApplication.myapp">
      <Generator>MyApplicationCodeGenerator</Generator>
      <LastGenOutput>Application.Designer.vb</LastGenOutput>
    </None>
    <None Include="My ProjectSettings.settings">
      <Generator>SettingsSingleFileGenerator</Generator>
      <CustomToolNamespace>My</CustomToolNamespace>
      <LastGenOutput>Settings.Designer.vb</LastGenOutput>
    </None>
  </ItemGroup>
  <ItemGroup>
    <Content Include="Icon1.ico" />
  </ItemGroup>
  <Import Project="$(MSBuildToolsPath)Microsoft.VisualBasic.targets" />
  <!-- To modify your build process, add your task inside one of the targets below and uncomment it.
       Other similar extension points exist, see Microsoft.Common.targets.
  <Target Name="BeforeBuild">
  </Target>
  <Target Name="AfterBuild">
  </Target>
  -->
</Project>

The diffrence in the two file formats are,

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.

So this shows you can still convert higher VS.Net projects to lower versions.