Developer Blogs to watch out for

With a plethora of blogs floating on the internet, it is hard to find the blogs which make a difference. Below is a collection of blogs of authors whose books we have read and blogs of people who make the technology.


I spent some time to find out such information and post it so that it will be useful for people who want to hear (read) from the horse’s mouth.


Below are the links of blogs of personalities whose blogs I find interesting to read:












































































Name


Covers


Blog Link


RSS


Atom


Charles Petzold (Windows programming guru)


Windows programming, C#, Indigo


http://www.charlespetzold.com


RSS


 


Don Box


Windows Architech (Microsoft)


http://www.pluralsight.com/blogs/dbox/default.aspx


RSS


 


Stanley Lippman


C++ guru


http://blogs.msdn.com/slippman/


RSS


Atom


Somasegar


Corporate VP, DevDiv, Microsoft


http://blogs.msdn.com/somasegar/default.aspx


RSS


Atom


Brad Abrams


CLR, .NET


http://blogs.msdn.com/brada/


RSS


Atom


Scott Hanselman


ASP.NET guru


http://www.hanselman.com/blog/


RSS


Atom


C# Faq


C#


http://blogs.msdn.com/csharpfaq/


RSS


Atom


Sahil Malik


ADO.NET


http://codebetter.com/blogs/sahil.malik/


RSS


Atom


Robert Scoble


Various Technology


http://scobleizer.wordpress.com/


RSS


 


Larry Osterman


Core technlogies


http://blogs.msdn.com/larryosterman/


RSS


Atom


 



There are many others whose blogs I read and I will be updating this site as soon as I get some time. If you feel that there is more to the list, please leave me a comment and I will check it out.


 


Who’s who in the list above:


 


Charles Petzold: The guru of Windows programming. Since Windows 3.1, he has been writing books on Windows programming. If anyone can talk on Windows programming, he can.


 


Don Box: The architect of the next version of Windows (Vista) and the geek (not Greek) mythology that shadows it can be answered by him and him only. When not confusing (enlightening) me on the future of Messages & designing the next generation of Windows, he takes time to write a blog and is quite humorous in his style.


 


Stanley Lippman: C++ guys should watch out for his blog


 


 


Somasegar: When the Corporate VP of Developer Division at Microsoft writes, the developers across the blog read, coz what he writes about affects their bread and butter. His is the blog to look out for happening in the Microsoft Developer Tools camp.


 


Brad Abrams: No one speaks of the CLR internals with as much clarity as the Lead Program Manager of CLR team at Microsoft.


 


Scott Hanselman: ASP.NET guys and .NET developers in general cannot afford to miss this blog. His post in the questions every .NET developer should know (link) should be familiar to anyone appearing for interviews for .NET positions.


 


C# FAQ: The C# team at Microsoft has a FAQ blog, which is updated by C# team and C# MVPS.


 


Sahil Malik: Kiss-ass attitude is what I like about his blog. His latest book Professional ADO.NET 2.0 is selling wonders. His language may be rough, but he gets his point across.


 


Robert Scoble: Think blog! Meet Robert Scoble. No, RSS does not stand for Robert Scoble Syndication, but this guys writes all about Microsoft, good and bad. Hats off to him.


 


Larry Osterman: His is a very geeky blog and he explains everything in detail.


 


Comments are very welcome and if my limited reading should be expanded, please mention who I missed in this list.


PS:.As I am writing this, I know Robert will scold me for not formatting it nicely. Sorry Robert, but I am a HTML dummy.

PDC content on Office 12 for free*

For 6 months, this content is free


OFF307: “Access 12”: Developing Collaboration Solutions with “Access 12” and Windows SharePoint Services “v3”
Speaker: Clint Covington – Broad overview of many new features.


OFF201: “Office 12”: Introduction to the Programmable Customization Model for the “Office 12” User Experience (Part 1)
Speaker: Jensen Harris – explains the philosophy behind the new UI and the ribbon changes.


OFF302: “Office 12”: Developing with the Programmable Customization Model for the “Office 12” User Experience (Part 2)
Speaker: Savraj Dhanjal – explains how to customize the new UI.


OFF310: Windows SharePoint Services: Developing Collaboration and Tracking Applications
Speaker: Mike Morton – explains many of the changes to WSS that can be used while building Access applications with WSS link tables.


OFF417: Visual Studio Tools for Office “v3”: Creating Office Application Customizations
Speaker: Andrew Whitechapel – details around how to develop managed task panes and addins for Office including Access


OFF415: Windows SharePoint Services: Developing Custom Workflows
Speakers: George Hatoun; Pravin Indurkar – details about workflow that can be used while building applications with WSS. Access will have hooks for working with WSS workflow.

Express Editions of Visual Studio and SQL Server for free*

Yes, for a limited time (1 year), Visual Studio express editions are going to be free. SQL Server Express editions will be free always.


More details at http://msdn.microsoft.com/vstudio/express/


Start downloading folks.


Clarifications on the free offer at http://msdn.microsoft.com/vstudio/express/support/faq/default.aspx#pricing


Complete FAQ at http://msdn.microsoft.com/vstudio/express/support/faq/default.aspx


And yes, you cannot develop V1.1 applications with VS2005 Express editions. ūüôĀ tsk tsk

Visual Studio 2005 Shipped

Soma (Corporate VP , Developer Division, Microsoft) mentions in his blog (http://blogs.msdn.com/somasegar/archive/2005/10/27/485665.aspx) that Visual Studio 2005, SQL server 2005 and Biztalk Server 2006 are ready for the market and have shipped.


MSDN subscribers can download from MSDN site.


The product will be launched world-wide on Nov 7, 2005 at San Francisco, California, USA.

.NET Compact Framework v2 is ready for download

.NET Compact Framework v2 is now ready and available for download !  As of today we have the English end-user download and the Platform Builder QFE available.  Remaining language downloads will be released in the new few weeks as we get the localized download pages completed.


.NET Compact Framework 2.0 End User Download
Component: .NET CF v2.0
Description: Integration of .NET Compact Framework v2.0 into Windows CE 5.0.



Windows CE 5.0 Platform Builder Update 051027_KB904260
Overview:  The Microsoft® .NET Compact Framework 2.0 Redistributable includes everything you need to run applications built for both NET Compact Framework v1 and v2, including the Common Language Runtime and the .NET Compact Framework class library

Using intrinsic memory management with C#

Consider the following code snippet


// Declare the reader.
SqlDataReader reader = null;

// Use the reader here.
try
{
    // Create the reader.
    reader = new SqlDataReader(…);

    // Use the reader.
}
catch
{
}
finally
{
    // Check the reader for null. If it is not, then
    // dispose.
    if (reader != null)
    {
        // Dispose of it.
        ((IDisposable) reader).Dispose();
    }
}


Here, we are checking whether the reader is disposed or not. If not, we are disposing it explicitly. This is equivalent to being a good C# citizen and disposing off variables which are not required.


There is now a even better method of automatic memory management. The “using“ keyword.


Here is how it works.


SqlDataReader data;
using (data = command.ExecuteReader(CommandBehavior.CloseConnection))
{
     while( data.Read() )

     {
         Console.WriteLine(“Company Name ” +
           data.GetString(data.GetOrdinal(“CompanyName”));

      }
}    // automatically calls data.Dispose();


 


Here is the link to the MSDN page describing this behavior (http://msdn.microsoft.com/library/default.asp?url=/library/en-us/csspec/html/vclrfcsharpspec_8_13.asp)


The beauty of this approach is that memory management becomes intrinsic. Hats off to the new keyword “using”.

How many threads does a typical managed process have when it just starts to run?

Source: Yun Jin’s blog at http://blogs.msdn.com/yunjin


Answer: regardless how many threads the user creates, there are at least 3 threads for a common managed process after CLR starts up: a main thread which starts CLR and run user’s Main method, CLR debugger helper thread which provides debugging service for interop debuggers like Visual Studio, and the finalizer thread which runs finalizers for unreachable objects. Depends on what the program does, CLR might create more threads to perform special tasks.   


Sometimes it is important to know what “special” threads would be created in CLR so we could understand better the implicit impact of our managed programs. Here is a list of most common special threads: 


1. Finalizer thread. The thread is to run finalizers for “dead” objects. This thread is created when GC heap is initialized during EE start up. In Rotor, the thread proc for the thread is GCHeap::FinalizerThreadStart in vm\gcee.cpp. Because GC is undeterministic and finalizers are executed in a separate thread, you can’t predict when exactly an object will be finalized. Because there is only one thread to run all finalizers, if one finalizer is blocked, no other finalizers could run. So it is discouraged to take any lock in finalizer. Also see Maoni Stephens’s blog for details about finalizer thread.



2. Debugger helper thread. As its name suggests, this thread helps interop debugger to get information of the managed process and to execute certain debugging operations. The thread is created when EE initializes debugger during start up. In Rotor, the thread proc for this thread is DebuggerRCThread::ThreadProcStatic (debug\ee\Rcthread.cpp). Also see Mike Stall’s blog about impact of this helper thread?



3. Concurrent GC thread (doesn’t exist in Rotor). As explained in Maoni and Chris Lyon’s blog, concurrent GC is a special GC mode which allows garbage to be collected while managed threads are running simultaneously. To achieve this goal, CLR creates a thread to perform GC concurrently with user threads. The thread is only created when CLR decides to do a concurrent GC (even when concurrent GC mode is on, not every GC is concurrent, read Maoni’s blog for details) and will be recycled when there are no concurrent GC work to do.


4. Server GC threads (doesn’t exist in Rotor). Maoni and Chris also explained Server GC mode where on multi-process machine CLR creates one GC heap for each CPU and one thread to do GC for each heap. When Server GC mode is enabled, server GC threads will be created at EE start up time when GC heaps are initialized.



5. App Domain unload helper thread. In CLR V1.X, when a thread requests to unload an App Domain and the thread is in that App Domain itself, it needs to create a worker thread to do the unloading work. The worker thread will be dead once the target AD is unloaded. In Rotor, the thread starts with UnloadThreadWorker.ThreadStart (bcl\system\Appdomain.cs). In Whidbey, all AD unload work is performed in a special thread regardless whether the requesting thread is in the unloading domain. The helper thread is created when first non-default App Domain is created (default domain is never unloaded) and will stay alive since then. Also see Chris Brumme’s blog about details of AD unload.


6. Threadpool threads. Depends on how a program use CLR threadpool, CLR might create threads of a varieties of types. There is only one thread for some thread type. For other types, number of threads is related to number of CPUs, the work load, and some user configurable settings. The thread types including wait threads (threads to perform asynchronized wait, could be more than one); worker threads (threads to execute user work item, could be more than one); Completion port threads (threads wait for completion port IO in Windows, could be more than one, doesn’t exist in Rotor); Gate thread (thread help to monitor status of completion port threads and worker threads, only one); Timer thread (thread manages timer queue, only one).

Zotob Free Removal Tool offered by Symantec

http://www.sarc.com/avcenter/venc/data/w32.zotob.removal.tool.html


 


More about it at http://www.trendmicro.com/vinfo/virusencyclo/default5.asp?VName=WORM%5FZOTOB%2EA

VSS – Timezone difference between VSS client and server

Imtiyaz says:


From: Imtiyaz Alamshah 
Sent: Wednesday, August 03, 2005 6:03 AM
To: Vipul
Subject: Query- Timezone difference between VSS client and server



Hi Vipul,

 

I have one query regarding VSS.

 

We have VSS server at onsite and working from india(OffShore) there is time difference of 4 and half hour between Onsite and OffShore.

 

We have problem with Time Zone difference. Suppose we check-in our changes at 5:30 PM (1:00 PM Onsite) then at 2:00 PM Onsite (6:30 PM OffShore) somebody label it to Version2.0. Our changes are not included in that label as time of label is 2:00Pm which is before check-in time 5:30 PM.

 

Can you please let me know if there is any solution available for it.

 

I believe that VSS server should consider Time Zone also as we are in +5:30 time zone and server in +1:00.

 

Is there any setting we can do at server side so server should consider time zone also with system time.

 

Thanks in Advance

Imtiyaz

 

 

Solution:


http://groups-beta.google.com/group/microsoft.public.vsnet.vss/browse_thread/thread/7e9056ec6730ab7f/c0ec004e840646e1?lnk=st&q=VSS+timezone+issue&rnum=1&hl=en#c0ec004e840646e1



 One has to be careful using SourceSafe over different time zones. The Time Stamp on the files being checked in are marked according to the client’s  configuration clock.  One way around this problem is to sync all computers interacting with sourcesafe acroos time zones to a common time. Another way is to use a third party add -on SourceOFFSite www.sourcegear.com.


</Extract>

VSS – Allow multiple developers to work on the same file – VSS project structure best practices

 


Got a mail from Narendra asking me about VSS project management:


Excerpts from the mail as below:


—– Start of email


—–Original Message—–
From: Narendra Bisht

Sent: Wednesday, August 03, 2005 5:30 AM
To: vipul_d_patel@hotmail.com
Subject: Hi Vipul : Query on VSS


Hi Vipul,
How are you doing? I was reading your Webchat transcript QA session at
http://msmvps.com/vipul/articles/48606.aspx. It was really quite informative. I have got few queries which are not related to VSS as such directly but more to management of Projects in VSS. Let me give you a brief overview of our current development environment.


We are into software development and develop solutions for our clients. As a typical SDLC, you might be aware that after implementation of application at client site, we had to resolve bugs whenever they occur, and for few projects after implementation, while we are supporting them we also have to do some fresh development/enhancement for the client. So as a result of this at times one file might be required by multiple developers, like one developer is fixing a bug while the other developer is doing some enhancement in the same file. And on top of this, we have to test the application by merging both the changes (bug fixing & fresh development). Now my query to you is that wha is the best project structure that we can create to handle such scenarios? We should also be able to keep track of our releases.


Right now, everything is a in a confused state, one developer have to wait for the other developer for finishing his work then only he can check out it and starts working. We are not able to finalise a structure where it will make the code version management a lot easier and quite smooth. Our proposed structure is defined below:


$Root
|
+———-Shopping Cart – Development (Project )
        |
        +____Code
        +____DB
        +____Images etc


+———Shopping Cart – Enhancement (Project)
        |
¬†¬†¬†¬†¬†¬†¬† +—–Code
        +___DB
        +___Images


+———Test
¬†¬†¬†¬†¬†¬†¬† —same structure as above——
+——–Release
¬†¬†¬†¬†¬†¬†¬† —same structure as above——


Pros of this structure:
1. We can seperate out bug fixing and enhancements related to a project seperately and later on can merge them, once successfully merged we send it to Test (create same project structure), test it and then release it to Release.


Cons of this structure:
1. Here there is lot of movement of files from one project to other project and we have to maintain 4 Projects for one single Project.


2. It also occupies a lot of space, if the project size is big.
3. It is also possible that lets say there were 4 bugs, now the developer has corrected 2 bugs and he is working on the remaining bugs, a second team member needs this file on which the developer has fixed 2 bugs coz he had some dependency on this file and since the 2 bugs has been fixed the second developer can resume his work with this file with these two changes, now we have to release this to a central place so that other developers can take it for their reference/dependency.


Hope you will be able to understand what I am trying to describe here. So, can you please suggest some project structure for the above mentioned problems, so that we can carry on bug fixing and enhancement as well as smooth partial and complete testing and then a smooth release of the application with proper RELEASE versioning.


Hoping to hear from you soon.
Thanks & Regards
Narendra


—– End of email


My solution


Narendra, first and foremost, you can have multiple people working simultaneously on the same file.


How to enable it? VSS Admin > Tools > Options > Enable multiple checkout.


This will enable multiple users to checkout the file. More details regarding the process to do this is available at http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnbda/html/tdlg_ch6.asp. Search for “Multiple File chechout” and you should be there. More info is available at http://msdn.microsoft.com/library/default.asp?url=/library/en-us/guides/html/vstskcheck_out_multiple_files.asp


Dont forget to check out how to resolve merge conflicts at http://msdn.microsoft.com/library/en-us/guides/html/vstskresolve_merge_conflicts_with_visual_merge.asp and http://msdn.microsoft.com/library/en-us/guides/html/vstskresolve_merge_conflicts_without_visual_merge.asp


The only drawback of this solution is that the developer needs to understand how to resolve merge conflict , lest it create more bug than to fix it.


Regarding the multiple folders which Narendra suggests in his email, I would not recommend them. Every branch in the VSS project seems to add a burden in the backup and restoring process and hence, I would like to keep as few maintainable branches as possible. Also if you use sharing feature in VSS, then you need to do periodic checks to verify the integrity of the  VSS structure. That alone is the deterent.


But Narendra has different requirements as per his mail






From: Narendra Bisht
Sent: Wed 8/3/2005 8:41 PM
To: Patel, Vipul
Subject: RE: Hi Vipul : Query on VSS



Thanks Vipul for a prompt reply, but your solution doesn’t fulfill my all the requirements, it is good for allowing multiple checkouts for a particular file but I had asked for VSS structure of the Project (basically best practices for organizing your project structure in VSS), so that we can handle bug-fixing, enhancements, their testing and finally Release of the application.

Hope you will be able to help me.

Thanks and Regards

Narendra

 

So here is what I suggested

 


—–Original Message—–
From: Patel, Vipul
Sent: Thursday, August 04, 2005 9:35 AM
To: Narendra Bisht
Subject: RE: Hi Vipul : Query on VSS



Hi Narendra,

the problem is that repeated branching affects the performance

 

BUt here is what will help you..

 

The solution assumes that the directory structure that your have outlines is being used.

 

Work on Shopping Cart – Development (Project ) is complete. Developer checks in all the relevant files to this stream. Release engineer then does a Get latest of this directory structure to the local path of the “Test stream“. And then he checks whether new code is ¬†buildable.¬† If yes, then he goes ahead and builds a release for an internal release. After building the release, he gives it to the testing team. The testing team verifies whether the developement effort is in the build or not. If yes, then this code is checked in to the Test stream. If not, the bug is reported and the developer is asked to work in the Shopping Cart – Development (Project ) stream and once again the cycle is repeated.

 

Once the test has confirmed that the build is good, the code can be checked in to the “Release stream”.

 

The same cycle will repeat for the “Defect fixing” cycle.

 

 

Essentially your suggestion for the streams is good and workable.

 

Regarding the cons of this structure: (inline)

1. Here there is lot of movement of files from one project to other project and we have to maintain 4 Projects for one single Project.

Since you require such a functionality, this is an necessray evil. The good thing is the specific groups will touch the specific stream. Developers will touch only the Shopping Cart РDevelopment (Project ) and the Shopping Cart РDefect Fixing (Project ). Testers will take code from the Shopping Cart РDevelopment (Project ) and the Shopping Cart РDefect Fixing (Project)  and check in into the Testing Stream.  Release enginner will take baselined code from the Testing stream (after approval from the test team) and check it into the Release stream.

 

2. It also occupies a lot of space, if the project size is big.

To reduce the space consumption, remove all .bin files, temporary files from the source control. If your project is a VS.NET project, do a clean project and do the diff between the folders on the VSS and your local drive. Any files which are not present in the local drive need to be removed. This will reduce a lot of space.



3. It is also possible that lets say there were 4 bugs, now the developer has corrected 2 bugs and he is working on the remaining bugs, a second team member needs this file on which the developer has fixed 2 bugs coz he had some dependency on this file and since the 2 bugs has been fixed the second developer can resume his work with this file with these two changes, now we have to release this to a central place so that other developers can take it for their reference/dependency.




This is a necessary evil. But you dont want a developer to use a dependency file which is not tested, do you?

 

Regards

Vipul

 




From: Narendra Bisht
Sent: Thu 8/4/2005 4:14 AM
To: Patel, Vipul
Subject: RE: Hi Vipul : Query on VSS



Hi Vipul, got ur prompt reply, one last thing, do u suggest that we should keep the same project structure along with all the files in all the 4 different projects e.g. Development, Defect Fixing, Testing and Release. If yes, then the size of the VSS will increase. And if we maintain 4 diff. projects in VSS for one SINGLE project then we will have so many projects. If we have 10 different Client projects then we will have 40 projects (10 X 4).

What do you suggest?

Thanks

Narendra

 






From: Patel, Vipul
Sent: Thursday, August 04, 2005 7:08 AM
To: Narendra Bisht
Subject: RE: Hi Vipul : Query on VSS


 


Hi Narendra,


 


Create a separate VSS database for each client project…. And¬† you can create thse databases on the same PC.. That will ensure that you only need only one server dedicated for CM activities.


 


Alterbately, switch to VSTS Foundation Sever. It has the solution to your projetc. i.e. it is like Rational Clearcase, which allows streams to be created.


 


Regards


Vipul

« Previous PageNext Page »