How do you look for code?
Another question, this time from one of the other PMs on the team:
The C# team is trying to understand how you look for code when stuck or trying to
learn some new technology. Currently the solution we provide is in the documentation
– you can find among other things –
- Walkthroughs on the product
- Documentation for each method
- How to articles that target specific tasks
- Code snippets
- Working pieces of code that we ship in the product that do a specific task.
How do you try to find code for a task that you don’t know how to write? Is the Help
content in VS organized well and is it adequate? What would you change to help
people ramp up on new code, tasks, or the capabilities of the tool faster? What annoys
you about the samples we provide today?
I think it’s always a combination of everything.
BUT, when I’m searching for something in a class I already used, the first place where I look for code samples is in the doc pages of that class and it’s methods.
It’s very frustrating to find a method "DoThis(param)" that says "Does this. param: the param to do this" and no code.
I always go to the SDK first. The format and level of detail in the SDK alone is phenominal IMO. For most of the APIs I don’t even need to look beyond the remarks to figure out how a method works, but there are occasions when the sample code built in for said method is useful. If I can’t find my answer in the SDK, I next turn to Google where I can usually find someone else who is suffering from the same confusion/problems as me. 😉
Related, I think would be differentiating between code that demonstrates a simple concept, and code that could be inserted into a production application. Too often, the former are used as the latter, when the code has some serious conflicts with best practices ( no exception handling). It might be helpful to mark the difference.
I use the MSDN library/SDK’s. If I have a good idea of what I am looking for, I will use the index otherwise I will use the search. I think I prefer (currently anyways) to learn the new stuff from technical articles as oppose to the Quickstart stuff. The code snippets in the documentation also help alot. The only complaint I have about the code snippets is that they mostly tend to be on a class overview and not available for each member, property, method etc.
Google. Period.
Indeed. Google.
The best thing that Microsoft can do is continue to keep the entire .NET help online, so that Google can index it. Then, it doesn’t matter how bad the organization is in MSDN (and it is pretty bad, especially when the same topic is covered one way in the SDK help, a second way in the Quickstarts, and a third in the VS .NET help); I can search through all of Microsoft’s code and everyone else’s with a single operation.
Rarely is SDK help my first stop. Newsgroups via groups.google.com provide much better searching based on the context of problems. But if that fails, I will try two-word combinations in the search of SDK help.
Also rare is where a sample describes my case, exactly. I think the samples could be better in terms of pointing out the ‘degrees of freedom’; the points where a developer can/should modify them to achieve different effects. This could be accomplished by more judicious commenting, but also by having *links within in-line SDK code samples* to classes and tooltips that better explain things.
(Slightly OT: Personally, I’m a big fan of hyperbolic navigation like "the Brain" and would love to see this in an SDK docs, but I doubt that would be viable for you guys since a lot of people really don’t like it.)
I would have to agree with the comments about Google, specifically Google Groups. Most of the time, I am not looking for help on how to use a particular method or class. I am looking for a way to do an overall task, and don’t really know what class I will end up using.
Usually, Google will give me the info I need, and then I can go into the documentation for that class to learn how to use it, although most of the time Google has that for me too.
There is a problem with Google, and that is new technology. When I first started with .NET, not much was out there right away, but as time goes on, more and more information is available – rarely (now, anyway) do I go away from Google without at least an idea of what I need to do.
I tend to look in my local MSDN library since web access is monitored at work (wouldn’t want them to think I’m always browsing). What might make the code samples better is to use highlighting in the code to indicate same salient point. I’ve seen the same sample used in various places to describe different aspects. Maybe, just highlighting (or bolding) the parts that are relevant to the issue would help. Using coloring similar to the VS IDE in the code sample would be nice (as compared to black text on a gray background).
I use a combination of search methods (the more obscure get called into play as needed). What is *REALLY* needed though is rich links between the various places the documentation is within MSDN/SDK docs–there are book excerpts, technical articles, columns, actual SDK docs, sample code, etc. and very little of that is accessible through any route other than direct search. Of course, keeping such links from breaking is nontrivial–but that’s not my problem ;).
Google mostly.
Everytime I go to use the VS Help it let’s me down.
If it’s a quick syntax check or I’m looking for something pretty specific, then the VS Help usually works.
But google usually seems to do the job better than anything else.
The samples need to be more non trivial examples. Just yesterday I was trying to find examples on deploying WinForms. I could not find any good examples. How to handle versioning, no touch deployment etc for a real production environment.
I’m a *big* fan of the MSDN/SDK doc browser. It would be nice if the QuickStarts and Samples were more easily accessible from the doc browser such as if there were links to open the sample folder or, better yet, to just view the sample code in the doc browser. Very rarely do I actually want to compile the samples, so being able to quickly view the interesting bits of code would be great.
Overall, more example code in the docs would be a great addition as would more real world examples.. Many of the asynchronous programming examples do things like start a thread and then call WaitOne() on its wait handle rather than actually showing work being done concurrently in the background.
My first stop is *always* the SDK/MSDN Help Library. I’ve never not been able to find at least something about what I’m looking for. The only complaint I have is that, if I’m trying to understand a new concept, the examples in the Help Library are too "real world"; they are concrete implementations of the concept, whereas I just want a simple cookbook receipe. If that fails, I start resorting to textbooks and various online references.
I really love the "101 C# Samples" package. Lots of good tidbits in there.
I usually use Google.
I’ve been doing a Java program here at work and I think the way the Java docs are layed out works pretty well. They have a program guide broken up into Trails that talk about how to do tasks an provide links into the reference part of the documention. The reference part has links back to the guide (very important).
In the Microsoft documentation, I like how once you find the method / class you need it is *usually* documented pretty well. The are the occasional "DoThis(param)" that says "Does this. param: the param to do this" and sadly they often occur in the stuff that isn’t widely used so Google isn’t much help.
Depends on the problem. If I just need to know some details about a specific class or method, the docs are usually the first step. However, when I don’t know the specific class or method I am looking for, or I can’t seem to figure out why a method is failing, google groups is usually the first step.
What could make me more productive?
Integrate exception reports with help: If a call to some DirectoryEntry method returns "Unknown Exception: 0x80000000" or something, it would be great to be able to load up a list of reasons why this exception would occur when calling this method. Or how ’bout a simple dialog about "how to avoid this type of exception" if it is a simple one like null reference exception. That would be great for beginners, who don’t know what the hell a null reference exception is.
Seperate code examples from class references: Usually, the example shows how to do something. I would much rather have more "how to do something" topics cross referenced by the methods / classes they call / create, than a million generic "how to call this method" examples. A lot of the time, the examples just seem like that thing we used to do in elementary school "Write this word’s definition, then use it in a sentence", which, of course, just produced thousands of meaningless sentences that didn’t do anything but waste the time of everyone involved.
Add more cross references: Again, using the DirectoryEntry example… Take a look at the documentation there, there aren’t any links to any relevant content on how to do things like create users in AD, etc. That information is all in the SDK docs somewhere, but for some strange reason, you can’t get to it from the class documentation. Very annoying.
Add multimedia to the docs. Hey, we are living in the 21st century now. Everyone has media player installed. How about adding videos from TechEd and other events to the docs so that people can get some good instruction on more complex topics? DVDs are cheap, people won’t ming paying the extra 50 cents in duplication costs :-).
What annoys me most about Microsoft samples is that they rarely follow good practices. Since a lot of developers still practice the "design by copy and paste from Microsoft samples", you see proliferation of some really bad coding practices.
Watching the demos of Yukon at the PDC, I was shocked that almost every demo (implicitly) promoted making the database server an Internet-facing device. After all the web server security problems we have had to deal with over the last few years and the best practices that have been developed around protecting databases, I couldn’t believe what I was seeing. The demos were really flashy, but not very practical.
I know that there is a sense of urgency in getting out as many samples as possible, but I wish that Microsoft would take more care to promote best practices in their samples.
My first stop is always my local MSDN, since it’s nicely integrated into VS. If that fails, I’ll usually check msdn.com, just in case there has been an update since the last Library release. Failing that, it’s off to Google/Google Groups. I rarely find the need to search anywhere else beyond that.
I guess my biggest gripe with the help is that it’s very hard to get started with a topic that I’ve never used before, using only MSDN. For example, I haven’t really done anything with WinForms data binding before, and when I look up the DataBinding property in help, I can find either overly simple or overly complex examples. It would be really nice to have some sort of simple "this is how you do DataBinding, and you need to follow these steps".
In my experience, I’ve found that I do better when starting out with a topic by reading a book on it, and MSDN works better for me to refresh my memory on a topic that I’ve previously learned.
The question addresses two problems – learning a new technology ("big picture") and ad hoc learning ("details") while coding.
The detail-aspect has been covered well in the other comments – MS help brower and Google.
For learning from scratch, however, I have used the "QuickStarts" as great shortcut. Working through the QuickStarts one by one and building small test apps based on the principles they expose provided me with a very solid foundationanl understanding of the entire framework.
All along, during the actual coding the SDK help browser is an invaluable asset, along with Google.
For inspiration and learning new facets I no longer read the trade mags and web sites: I read blogs like this one and find these to be much more useful for non-goal-directed learning than traditional resources like books and magazines…. so keep blogging!
Framework SDK then Google. Maybe it’s just me, but I think most people don’t know or forget about the Platform SDK.
SDK examples are great. I think the next level is to add addtional references, maybe to task specific examples that put a class/method into context. Sorry guys…
A concrete example: "C# interface property" search in MSDN: 500 hits. First two are about the Word and Excel object models. First 20 do not appear to be relevant to the task of defining a property on an interface in C#.
"C# interface property" search on Google: 62,700 hits. First one is to the MSDN page on the C# Interface Property Wizard. Next one is to the correct section of the ECMA language spec. #5 is another C# grammar. #6 is a page with sample code from CSharpHelp.com.
As far as I can tell, the C# Interface Property Wizard isn’t in the first 500 hits returned by MSDN’s own search.
"Documentation for each method" – only to check for exceptions thrown, and for possible remarks if something goes wrong, like "this is not supported when that is true". All in all for me documentation lacks general views of subsystems, places particular piece fits in the picture and so on.
"Code snippets" and "How to articles that target specific tasks" – they are too simple for me. When I get stuck in the problem it’s usually way complex than those answers in how-to’s. As somebody noticed before, they often lack design guidelines conformance and such.
Google Groups is main source of information for me. Definitly. What could improve MSDN is selected and refined excerpts from newsgroup discussions, especially particular problems solved. Yes, that’s hard work 🙂 Also, I vote for more information aimed at advanced developers, rather than quick-starters.
I actually like the VS documentation and think its great, however I think the searching of said info could be better. I’d like more options on the search pane to only choose examples, or perhaps things like best practice examples, authentication examples etc., or other types of search criteria. I also agree with a number of others that google is king.
I look at the code – both Mono and the SSCLI. If I had the code for the DataBinding ‘lump’ of .NET my day’s would be happier!
When I need information about e.g. a specific method, I’m always happy about code snippets in the method’s documentation. The shorter the snippet, the better. The larger it its, the more I’m inclined to hit Google groups (usually with good results). If you want to show different aspects of a method, show it with several small code snippets, not with one large one. Never forget: developers under pressure are *very* impatient.
I must admit that I have always found a solution to a specific problem before I even thought about looking at one of the external samples (sorry for the guys who wrote those samples…). When I need information on more complex issues, a search on Google usually brings up an article on a community site like e.g. CodeProject.
Normally google first. The problem with MSDN is that there’s too much information in it and it’s no good for contextual searches. Ever tried finding information on win32 commands in VS? – you have to go through MFC help pages almost every time. Not good. I don’t use MFC, but there seems no good way to filter it out.
Look at how people search google groups for help with your technologies, and try and build similar facilities around the wealth of information available to you.
As far as samples are concerned, the ones for the .NET framework are quite good – there are lots of them – but you generally don’t show the expected outcome of the sample. Lots of calls to Console.WriteLine etc. and no idea of what the result will be. Better comments in your snippets and example output would be good here.
To add to your list (and these are things that you guys already do):
– Application Blocks to show best practices for specific Architectural implementations.
– In depth samples to show best practices wtih a specific technology, like a Remoting Client/Server example that is fully implemented. Noobs to Remoting and other things you might not have done (multithreading sample in winforms, etc.) need that stuff.
More of these that show BEST PRACTICES. The code snippets and samples should state for noobs that the implementation of the sample is not a best practice, "please look at this sample for one impl of best practices…" to further their education.
My wife went to a VBITS last year and it turned out to be beneath her level of skill, but it was noted there (by Rocky L or somebody) that 90% of ppl who write code using MS products write badly architected code. This is not just a VB problem, I have consulted on VC, VC++, C#, VB5,6,.NET projects and in most cases the code quality is the main reason I was brought in to bail them out. You guys have the defacto responsibility to drive the education of coders out in code land.
To learn the basics of a language the .NET SDK is adequate and will help you learn. However, when you want to branch out, then google is the place to search. The reason for using google is that there’s a possibility of finding more specific answers/ideas than the SDK contains.
If I were to add anything to the SDK it would be better exception documentation. For example, you could have a slew of testers try to come up with exception cases and offer reasons why the exception may have occured. Right now showing exceptions aren’t real specific and are general.
I always have the dynamic help window visible, then if I get stuck on a method/property I have quick access to the help docs, also I really like the way that you’re generally given more than one option to choose from. Failing any help from the dynamic help I try a keyword search. Failing that Google.
For error codes and messages, first stop is always Google.
One feature that would be nice to include would be a way to annotate the help docs.
I usually try to search the VS Help first, but many times the docs only show information about the methods but don’t give any examples. When there is no example I usually search google for an example.
Firstly, I want to see an integrated read-eval-print-loop – for learning by experiment, nothing beats having a quick and dirty command line to try things out on. I believe that Whidbey implements this, but lets hope its as full featured as, say, the Python command line interface.
Secondly, some posters have mentioned the "best-practices" effect that demos in the documentation have – these demos need to be the very best examples of C# programming practice there is – not just minimal throwaway snippets demonstrating one narrowly focussed behavior. Thats not to say that the code in the documentation has to be full programs, just that it should be exemplary coding. The key word here is "exemplary".
Thridly, like everyone else, I use google a lot. It might pay to develop specific short phrases or codewords that would help people find msdn code samples. Hmm, this isnt a fully thought out idea…
I agree with Diego that the examples in the MSDN documentation need serious revision. Examples should show a scenario which illustrates the purpose of the method, not just the calling syntax. If no short example can be provided, provide a link to a suitable sample. An example, I challenge anyone to understand how to use HttpContext.RewritePath method from reading the SDK documentation alone.
Google and Google Groups.
sorry 😉
Code snippets in method documentation is the best. Surprisingly, I very rarely use samples in the SDK. In the worst cases I look for code on the community sites – codeguru, gotdotnet and the like.
The provided help is usually excellent, with the exception of the examples. Too often, these are next to worthless.
Take, for example, the examples given for the String.Format method. The important thing that leap out at me is that no where does the example show what the RESULT of the call to Format is. Since this method is typically only used display data to the user, I would think this would be an important part of the example.
Echoing other’s thoughts above, the examples are also need to provide more real word examples of when/how they should be used. This is particularly true under the Visual Studio auotmation (which I think contains some of the most useless documentation in all of MSDN) and under some of the larger base classes (like System.Windows.Control).
Context help first, then google, then maybe MSDN online, but that last one is sketchy at best. It’s so common to put "C#" in a search on MSDN and get 800 C++ responses or WinCE responses.
The context sensitive help is the best, but there are so many classes and methods that have no code examples that you’re bound to run into a barrier there. Google nearly always comes back with something relevent. I think another feature to context sensitive help would be to include some memory of when you actually used a class so in the list you would see the library help, then "Used in…" and then a list of class files where you used that code.
I look for code in the following places:
1. MSDN Library
2. msdn.microsoft.com
3. Google groups
4. .NET 24/7 website
5. Books
If I were to estimate, I’d say 75% of the time, I use the .Net Framework documentation. Most of the mildly-more-than-difficult methods have short samples that are fine. Maybe 15% Google Groups (especially for non-MS stuff like HTML, CSS), and the rest via the MSDN tutorials.
Eric,
Love your work!
Looking for code? Good question. Not sure how many books on C# I have, but I usually start with the help. Unfortunately, help is often not that helpful: examples are missing. We get a brief amount of technical detail on a particular member, what that member belongs to, but unless we know the hierarchy which leads from the broadest namespace to the specific class which has that member, we can’t use the class or the member. Next, I will go to the net (a.k.a, Google). Perhaps I will search for the particular member and/or class with "C#" as an additional search term. Or, and I found this useful just today, perform a search for a VB6 term in combo with "C#." I will also Google the newsgroups, sometimes. And now that I know that Google doesn’t cover every newsgroup on the Microsoft news server, I will be looking at that as well.
What would help the most? The chain, leading from the broadest namespace to the class to the member. Currently, Microsoft seems to be doing a great job with IntelliSense in taking us from a broad namespace to a member, but oftentimes we will already have the member and class — just not the chain which leads to them.
I always check out the SDK documentation first.
But it’s really two cases:
1) I know I need to use a quite particular class/method to accomplish something.
Something like how do I get the path for the user’s application data? That’s something I’m very sure must be a method/class..
2) I’m more looking for something more high-level, like how to create a Windows Forms custom control.
For case 1 I start by browsing the reference section of the SDK for a 1-5 minutes maybe. If I can’t find it there, then I use the search function to see if that gives me something. Next I’d check if there is some technical articles/books/etc in MSDN Library which could be about this topic. If I still can’t find it I can start assuming that this class/method doesn’t exist 🙂 but I’ll try to search google and google groups too. Usually this should give me some result 🙂
For case 2 I skip the "browse the reference section" and starts checking for technical articles about this issue. MSDN Magazine rocks :). And then I do quite the same as for 1.
So, for me MSDN Library usually gives me what I need to know and I really like it. IMO this is one of the best parts about using Microsoft-products: it’s always quite easy to find documentation and samples.
From my experience I liked the walkthroughs when I first started to learn C# for example, but these days I don’t look at them anymore. But they were good to me when I needed them 🙂 I’m not quite sure which of the other options to "get code" is best. Depends on if it’s a "case 1" or a "case 2". For "case 1" the documentation about each method with a nice little example showing how to use the method is usually quickest to find & use.
I think MS has come a long way in documentation in the past few years. There are some really good enhancements of late, and I look for most of my samples/docs in the MSDN Library and then on google.
What i’d like to see from the MSDN library:
1) A way to save favorites that DON’T go into my IE favorites?? seriously why the hell would I want them there? At least give me the option? (Maybe I’m just nuts, but I can’t stand this new ‘feature’).
2) I’m honestly amazed at how much documentation there is, so I realize it must be ha HUGE feat comming up with examples of every member of every object out there. That being said, here’s what I see as being the main problems with most examples out there: a) many are just simple cheesy hello-world type examples that don’t really show you how to use a member correctly. b) many of the examples are, again, cheesy in the sense that they’re really just for ‘dummies’ who are making two-tiered apps — not for people trying to make performant and well designed REAL WORLD apps. Or.. then there’s the other case c) where the examples are so complex and so barely related to the subject at hand to almost make them useless. (And yeah, anyone can complain.. it’s hard to give concrete examples — which i don’t have time for right now *grin*).
3) howzabout an ICON for members that are part of the compact framework? Just a little PPC icon would let me know instantly that it was compact safe — instead of that same dry text over and over again.
4) make LANGUAGE documentation easier to get at… maybe I’m wrong but there should be a top-level node for languages… and then you could jump down into each language for examples/reference right away.
5) walkthroughs/tutorials should also be aggregated to a top-level node instead of being hidden way down in who know’s where.
6) Seems like when I’m looking for something like @page directives or @control directives… it takes forever to find what node those little bleeps are hiding in. My hunch is people have similar problems finding aspects of the framework (specifically syntax, best-usage, etc) for winforms, windows services, webservices, etc. The reference on the framework classes themselves is VERY well done (though some things are REALLY sparse)… everything seems to flow so intuitively. Howzabout some type of node that housed asp.net,winforms,windowsservices, console apps, etc…
Anyhow… I think it’s great MS is soliciting feedback.
–Mike
I agree with Mike on the notion of a top-level language choice. When I look at documentation in MSDN, I have to scroll past the VB stuff to the VC# stuff. When I was doing C++ code, I was flat-out screwed. A preferred-language setting for help system ala a style sheet would be great.
I disagree, though, on the placements of favorites in IE. I like the idea of "universal favorites," although filtering per-app (or just simply grouping) would be good.
Anyway, there is a blog thread on Tim Sullivan’s blog about MSDN help: http://blogs.gotdotnet.com/timsull/commentview.aspx/bd075a79-1033-4cd2-9611-815e90ee274c
I am a very bad boy because I don’t look enough for code.
Instead I reinvent the wheel.
This is because I generally am disappointed in my search for code.
But I DO look for mathematical algorithms more than the average programmer in resources including Numerical Recipes and Knuth.
I consider code reuse to be too often the evil twin of using sound theory.
As to the help: please improve it. Too many times the index takes me to subjects in which I have no interest such as JavaScript when I am working on C#.
One area where I do like to see code is where I am learning a new approach.
Google baby! It’s great to have a single home-base from which to search for so much stuff. Now, if I just had google for my hard drive. 🙂 BTW, there was a time (not too long ago) when Google did a much better job of searching the MSDN web site than the MSDN web site’s search feature.
I use MSDN docs and Google groups.
What I’d really like to see in the docs are more examples and How-tos. And most importantly, link to these examples from the classes and methods documentation.
First stop is always Google. Second is MSDN. Third is SDK docs.
To me the greatest challenge is finding the "magic keywords" that will produce the answer(s) I’m looking for. Often the word I’m thinking and using to search isn’t word I need to find the solution I’m looking for — so it’s a metadata problem. ie. My "lookup" or "find" is your "search". I’m usually fishing in the right pond but with the wrong lure.
I think the single biggest improvement would be to have more task oriented topics — "How Tos".
Plus, I _love_ the fully working samples in the documentation!! Being able to cut-n-paste those into a sandbox project and then play around with it is great! Especially when you’re cutting your teeth on the technology and are feeling a little uncertain.
CODE SNIPPETS are the most useful documentation.
When I use help, I usually want to know about a specific method or class. Class, method and parameter descriptions can be helpful (assuming they actually contain information beyond "parameter foo specifies the foo"), but code snippets are the fastest way to grok a something. Keep snippets short and to the point.
Like everyone else, if I’m looking for something more involved than information about a class or method, I go straight to Google. Sorry, but the MSDN search just isn’t worth it.
Basically, the most useful documentation feature is CODE SNIPPETS.
Google first, MSDN Library second.
I think as many others have said, Google is the first stop. Secondly, I try to find code on sites that are not always indexed correctly or often enough by Google (like GotDotNet), my favorite is CodeProject.com. Usually, someone else has already written what I am looking for 🙂
Finally, I will search the MSDN documentation, though I find it difficult to find what I am looking for most of the time.
Google first, MSDN as last resort!
1. VS.NET Help Index for the type reference (when I have a good idea of what I want to do).
2. VS.NET Help Search for a broader lookup.
3. VS.NET Walk-throughs and other general SDK documentation are good for those things that you don’t do often like creating a Windows Service or building a custom action for a setup project.
4. I have a set of favorite sites to search such as MSDN, GotDotNet, Code Project, ASP.NET Community Site, Windows Forms Community Site.
5. Google is my friend. 🙂
6. My most recent new resource is Blogs. However, the signal to noise ratio varies, so they are part information resource and part entertainment.
7. I think Snippets have great potential.
Personally, I tend to follow the below myself.
(1) I use the F1 a heck of a lot in VS .NET IDE on methods and hope that that method has an example of its funcationality.
(2) Good ol’ google.
Also, as for the VS IDE integrated help I was wanting to pass along an item concerning the samples that would help make it a heck of alot easier to use would be to make every type name its full name and not use the using statement in examples. This would make the code a lot easier to follow since the namespacing can get confusing in some instances and make copy-paste-test a lot easier as well.
Thanks.
Your question seems to be in two parts. How do we get a general understanding and how do we lookup specific information.
The general case:
1) read a chunk of a well written book
2) Rarely the VS .NET help tutorials (too mickey mouse)
The specifics
1) VS .NET index to find the details of a method. (this often fails as Diego (1st comment), said – documentation often just echo’s the param name).
2) Google looking for examples that demonstrate the method I need to understand.
This can be very frustrating on the outer limits of the SDK (drawing with various brushes; no touch deployment, arguement passing to winforms apps deployed in a plain html page), where very little is well documented and there are few solid examples to guide you.
I look to rotor code. Always nice to see how MS coded things.
Can provide :
1. how to code things.
2. what not to do
3. perf insights
Would be nice to see more in the next SSCLI such as Datasets…
For a long time you couldn’t search for info about C++ because the + got interpreted as either a space character (through weird URL encoding) or a "must include this result" marker in various search engines. Gradually they adapted, so now it’s OK.
When C# came out, my first response on hearing the name was "what, don’t Microsoft learn from anyone’s mistakes?" And at first it was impossible to find info because the hash symbol got stripped out, but the situation improved again.
Oh, and put me down as a vote for Google as the number one doco tool. It’s even more useful for Open Source languages, where the source of entire programs, not just examples and tips, is available on line. For example, using Google and a bit of creative query-twiddling, I found a magnificent open-source 3D graphics library last night that I’m using to build a programmable robot for my 6-year-old daughter. Sorry – it’s in Delphi, but I’m sure Anders has a secret Delphi-to-C# converter that you could borrow…
Helpful For MBA Fans.
[http://itpeixun.51.net/][http://aissl.51.net/][http://kukuxz003.freewebpage.org/][http://kukuxz001.51.net/][http://kukuxz003.51.net/][http://kukuxz005.51.net/][http://kukuxz002.51.net/][http://kukuxz004.freewebpage.org/][http://kukuxz007.51.net/][http://kukuxz001.freewebpage.org/][http://kukuxz006.51.net/][http://kukuxz002.freewebpage.org/][http://kukuxz004.51.net/][http://kukuxz008.51.net/][http://kukuxz009.51.net/][http://kukuxz005.freewebpage.org/][http://kukuxz006.freewebpage.org/][http://kukuxz007.freewebpage.org/][http://kukuxz009.freewebpage.org/]
PingBack from http://restaurants.247blogging.info/?p=653
PingBack from http://caferestaurantsblog.info/eric-gunnersons-c-compendium-how-do-you-look-for-code/
PingBack from http://cellulitecreamsite.info/story.php?id=5615