Monthly Archives: March 2012

Can’t see a Windows XP machine from a Windows 7 Machine

Filed under Networking, Troubleshooting

I ran into a strange problem today. I had brought up a new Windows XP machine, wirelessly connected to my network. It has SP3 installed, could see the internet, and could see other machines (including Windows 7 machines) on my network.

But, my Windows 7 workstation could not see the XP machine.

By “see”, I mean:

  • it didn’t show up in explorer
  • I couldn’t ping the machine by name
  • I couldn’t browse to the machine by using a unc (like \\majestic\Drivec)

However, I had another XP machine that my Win7 workstation could see!

After a few google searches, I came across a post that mentioned changing a few Win7 networking settings.

In particular:

Open up Advanced Sharing Settings


And alter a few settings:


Notice that

  1. I’ve set File Sharing Connections to the 40-56 bit encryption option
  2. I’ve set Password protected sharing to OFF
  3. I’ve set HomeGroup connections to “Use user accounts”

I then logged out and logged back in (no need to turn off).

Presto! I can see both of my XP machines!

Ok, so which settings actually did the trick?

Long story short, I ended up setting ALL these settings back to their original values, rebooting between each, and even using IPCONFIG /flushdns, but I can still see my XP machines just fine.


In the end, I’m guessing switching those settings allowed “something” about the XP machine to register itself on my Win7 machine, after which, I could switch the settings back, but everything will still be OK.

But that’s just a guess at this point.

Visual Basic 11 beta is out

Filed under .NET, Rants, VB Feng Shui


OK, It’s been a few weeks, so this is likely not “new” news, but still.

Looks like MS isn’t backing off on VB one bit, and that’s a good thing. Heck, as I understand it, there’s even a project in skunkworks build VB in VB! I’ve always said the mark of a complete language is when it’s actually written in itself.

But I digress. Back to VB 11. The VB Team website has a nice rundown of some of the high points of the release here.





To summarize:

  1. Async support. Meh. VB (actually any .net language) has always had this. The Async stuff definitely makes it easier, so I won’t complain too much. Personally, I’ve kind of gotten into the Javascript notion of lambdas for callbacks in support of async stuff. You can do that in VB, but lambda’s, being limited to single lines) haven’t been all that useful for it, up till now with….
  2. Multi-line Lambdas. That’s right, you can finally declare a Function()….. lambda that spans multiple lines.
  3. Iterators. Which basically means a Yield keyword that can fall out of an iteration loop to allow the iterating code to perform it’s work.
  4. Caller info. This is a big one for me. I’ve written more than my share of error logging/trapping/handling frameworks over the years, starting with VB3, on through VB6 and then into .net. Unfortunately, this feature has nothing to do with that!
    Caller info allows a function to easily and straightforwardly retrieve the Name, Line number or FilePath, of the calling function. While the Line number and Calling path are of dubious value, the caller name is incredibly powerful for things like front ending field accessors in data access libraries. Say you have a small function that retrieves a value from a VB, via a name. With this feature, you can easily create properties of an object that are named that name and then pass the property name down to the accessor function to retrieve the value.
    This has been doable for ever in .net as well (via the call stack), but was not straightforward and was susceptible to corruption if you used code obfuscators. No word on whether this feature will play better with obfuscators at this point, though.
  5. Call View Hierarchy. Looks like a very nice feature, but I’ll have to play with it more before making any concrete observations.
  6. Global Namespace. Another meh. On some projects, I could see this being handy. But it’s nothing to get too excited over. A very incremental improvement.


What’s missing

  1. Unsafe code. At least, I’ve seen no mention of it.
  2. Property-level scope. They added auto properties in VB10. Property-level scope seems like the next natural step for that. And by this, I mean:
    Public Property Name() as string
         Private _Name as string      <—– Property level scope
          End Get()
          Set ()
          End Set
    End property

    EDIT: The suggestion that I posted to MS’s suggestion board ended up getting a comment from Lucian Wischik. You can read his full comments here.
    Property Scope Variables
  3. More Dynamic functionality, though you could argue that you can actually do quite a lot of dynamic stuff now in .net languages.

It’s good to see the language getting very close to parity with C#, and the news of a forthcoming coded compiler is even more exciting.