a has become b Results

Page 1 of 2.
Results 1...20 of 40

Sponsored Links:

Hello my name is Nick and I have had my computer for about 7 months now. I have had many issues with it including bad RAM and what not. My latest issue is BOSD let me try to describe how it happens. I will be watching a youtube video and my computer will completely lock up. And the last sound made will loop for about 5 -7 seconds while I can still see the desktop but have no control over it. The I get the Blue Screen in my case "A clock interrupt was not received on a secondary processor" I feel that it may have something to do with Flash but im not sure. I dont have any viruses and I have already done a clean windows install and my BIOS is up to date. This has become a real pain as I am a live steamer and the BSOD sometimes happens during the live stream. Here all files I was told to put in. Thanks for your help in advance and I hope we can find a fix.

Seven Forums.rar

RAMMon v1.0 Build: 1005 built with SysInfo v1.0 Build: 1027
PassMark (R) Software - www.passmark.com

Memory Summary For NICK-PC

Number of Memory Devices: 2 Total Physical Memory: 8173 MB (8192 MB) Total Available Physical Memory: 5824 MB Memory Load: 28%
Item Slot #1 Slot #2 Slot #3 Slot #4 Ram Type DDR3 DDR3 Not Populated Not Populated Standard Name DDR3-1333 DDR3-1333 Module Name PC3-10600 PC3-10600 Memory Capacity (MB) 4096 4096 Bus Clockspeed (Mhz) 666.67 666.67 Jedec Manufacture Name Kingston Kingston Search Amazon.com Search! Search! SPD Revision 1.0 1.0 Registered No No ECC No No DIMM Slot # 1 2 Manufactured Year 0 Year 0 Module Part # 9905403-400.A00LF 9905403-400.A00LF Module Revision 0x0 0x0 Module Serial # 0x4814CADA 0x571411DC Module Manufacturing Location 4 4 # of Row Addressing Bits 15 15 # of Column Addressing Bits 10 10 # of Banks 8 8 # of Ranks 2 2 Device Width in Bits 8 8 Bus Width in Bits 64 64 Module Voltage 1.5V 1.5V CAS Latencies Supported 6 7 8 9 6 7 8 9 Timings @ Max Frequency 9-9-9-24 9-9-9-24 Minimum Clock Cycle Time, tCK (ns) 1.500 1.500 Minimum CAS Latency Time, tAA (ns) 13.125 13.125 Minimum RAS to CAS Delay, tRCD (ns) 13.125 13.125 Minimum Row Precharge Time, tRP (ns) 13.125 13.125 Minimum Active to Precharge Time, tRAS (ns) 36.000 36.000 Minimum Row Active to Row Active Delay, tRRD (ns) 6.000 6.000 Minimum Auto-Refresh to Active/Auto-Refresh Time, tRC (ns) 49.125 49.125 Minimum Auto-Refresh to Active/Auto-Refresh Command Period, tRFC (ns) 160.000 160.000 DDR3 Specific SPD Attributes Write Recovery Time, tWR (ns) 15.000 15.000 Internal Write to Read Command Delay, tWTR (ns) 7.500 7.500 Internal Read to Precharge Command Delay, tRTP (ns) 7.500 7.500 Minimum Four Activate Window Delay, tFAW (ns) 30.000 30.000 RZQ / 6 Supported Yes Yes RZQ / 7 Supported Yes Yes DLL-Off Mode Supported Yes Yes Maximum Operating Temperature (C) 95 95 Refresh Rate at Extended Operating Temperature Range 1X 1X Auto-self Refresh Supported Yes Yes On-die Thermal Sensor Readout Supported No No Partial Array Self Refresh Supported No No Thermal Sensor Present No No Non-standard SDRAM Type Standard Monolithic Standard Monolithic Module Type UDIMM UDIMM Module Height (mm) 30 30 Module Thickness (front), (mm) 2 2 Module Thickness (back), (mm) 2 2 Module Width (mm) 133.5 133.5 Reference Raw Card Used Raw Card B Rev. 0 Raw Card B Rev. 0 DRAM Manufacture ID 0 0 # of DRAM Rows 0 0 # of Registers 0 0 Register Manufacturer Register Type Register Revision 0 0

Don't want to make this too long winded so i will try to be concise.I'm a construction guy by trade but have been interested in computing my hole life and it's been an intense hobby for about the last ten years.I am certain that i'm in possesion of the skills to do almost any consumer/residential computer servicing/repair, and with the construction holocaust that is going on now i've decided to turn an unused skill into a new career. I think the best move for me considering that i don't fit in well in the corporate environment would be to start a small home based buisiness.To that end i have decided to gather A+, net+ and security+ certificates A, to conso;lidate my skills and B, to have something for a business to advertise/legitmize itself with.I think MCSE would be overkill, i am looking into becoming an HP Accredited Service Provider i have confirmed that to be a gold mine from several sources. My main question relates to the difficulty of the A+ testing i feel like the company i signed up with has sort of shafted me, misleading warranty,inadaquate materials,ETC. I have absorbed and categorized all the lousy infortmation they offered and am able to perform quite well on ther practice tests however i have reason to believe that these may not be indicitive of the actual tests from vue and prometric.How difficult is this test and more importantly. how much more difficult are the Net+ and Security+ so that i can try to detimine the length of shaft that quickcert has inserted and how much i should fight for a refund on the two later courses befor i begin them.They are a major company it seems and i'm hoping someone on here has personal experience and can tell me how there window's for dummies course stacks up to what i will really need to know for these certs. Personal experience with the difficulty or knowledge level tested by these three exams would also be extremely helpful.

Thanks to all who reply.

This year alone they will be responsible for infecting in excess of 25 million computers worldwide, but they could come close to compromising as much as 30 million machines. At the root of this epidemic lay simple social engineering tactics designed, through various methods, to convince victims to pay for peace of mind. Responsible for the actual infections are pieces of malicious code that the software industry refers to under a variety of monikers, including rogue antivirus, fake antivirus, scareware, etc.
Microsoft has put together a list containing no less than 114 AV rogues which are detected by the company’s antivirus products, including Microsoft Security Essentials, Forefront Client Security, etc. It is important to note that the list contains only the official label provided by the software giant. Each of the items featured below come in a variety of packages and under a plethora of brands, which actually makes the number of fake antivirus in the wild much larger.

Users that have doubts related to a security solution that is being aggressively advertised to them should first check to make sure that the offering is indeed genuine. Microsoft, but also additional members of the security industry, constantly update information on threats posed to end users, including rogue antivirus, and publish it on websites that are available to the public. These details are available to the public, and are essentially no more than a search away, at any given time.

“On page 100 of our Security Intelligence Report volume 7, we observed that rogues remained a significant threat even though they trended down to 13.4 million infected computers in 1H09 from 16.8 million in 2H08. (Internet Explorer 8 SmartScreen Filter, a browser-based security feature, contributed to part of the decline),” revealed Scott Wu, from MMPC.

Modus Operandi

“Rogue security software—software that displays false or misleading alerts about infections or vulnerabilities on the victim’s computer and offers to fix the supposed problems for a price—has become one of the most common methods that attackers use to swindle money from victims. These are programs that masquerade as legitimate security programs offering protection from malware, spyware, and other threats, but actually use social engineering to obtain money from victims, and offer poor or nonexistent protection,” the Redmond company reveals in SIRv7.

Fake antivirus will take it upon itself to run a scan of computers belonging to unsuspecting users. Of course that the scan itself and the results offered are both fake. Rogue AV doesn’t actually analyze machines, nor is it capable of detecting any malware, or to remove it. It’s all smoke and mirrors, a show put on to trick users into thinking that their computers is infected with malicious code.

“Rogue security software programs typically mimic the general look and feel of legitimate security software, claiming to detect a large number of nonexistent threats and urging the user to “activate” the software to remove them. Some families emulate the appearance of the Windows Security Center or unlawfully use trademarks and icons to misrepresent themselves. Rogue security software spreads through familiar malware distribution mechanisms, like spam and exploits, and through customized tactics, like a fake Webbased security scanner. After installation, some rogue security software families take other actions to evade detection or to frighten the user into paying,” Microsoft explains.

Once installed on a Windows PC, fake antivirus programs will attempt to scare the user into believing that various infections were detected. Rogue security solutions are designed to look very similar to genuine AV products, often copying at least elements of the graphical user interface, if not the whole UI, as well as using brands and labels mimicking, or even plagiarizing valid security offerings.

And integral part of the social engineering tactics deployed is to convince the user that the rogue AV is a genuine security solution, when in fact, much to the contrary, it is only masquerading as such. The fake AV will bombard users with alerts, and annoying, repetitive, incessant notifications, reporting inexistent infections.

At the same time, the rogue AV advertises the possibility of removing the fake infections, provided that users buy the software. Once a license is acquired, the fake AV ceases from delivering fake reports, creating the illusion that whatever malware had compromised the computer, was removed. Obviously, in this scenario, the users have been scammed into paying for protection against an inexistent threat.

“Though fooling users into paying for worthless software remains the primary goal of most rogue security software, several recently released families have begun to branch out and exhibit behaviors common to other threats, such as downloading additional malware to a victim’s computer. Win32/Winwebsec has been observed to download Win32/Koobface— which itself sometimes displays pop-up advertisements for rogue security software. Win32/InternetAntivirus, which was added to the MSRT in June 2009, downloads the password stealer Win32/Chadem,” the company added.


“As we have done in the past, we again encourage our readers to run a complete, up to date AV product such as Microsoft Security Essentials to protect their computers from these rogues, especially if located in English speaking countries - the regions where these rogues appear most active (as highlighted in the SIR). MSRT is a baseline tool we provide for the ecosystem to remove prevalent threats such as high profile rogues. With Security Essentials, on the other hand, you get the benefit of the complete AV signature set from the MMPC and you get the essential protection features an AV solution needs – real time, kernel mode detection, scheduled scan, complicated cleaning functionalities to address the em114 Windows “antivirus” to avoid at all costs

1. Win32/FakeXPA – Aliases: Win-Trojan/Downloader.56320.M (AhnLab), Win32/Adware.XPAntivirus (ESET), not-a-virusownloader.Win32XpAntivirus.b (Kaspersky), FakeAlert-AB.dldr (McAfee), W32/DLoader.FKAI (Norman), Mal/Generic-A (Sophos), XPAntivirus (Sunbelt Software), Downloader.MisleadApp (Symantec), XP Antivirus (other), Antivirus 2009 (other), Antivirus 2010 (other), Antivirus 360 (other), Total Security (other), AntivirusBEST (other), GreenAV (other), Alpha Antivirus, other), AlphaAV (other), Cyber Security (other), Cyber Protection Center (other), Nortel (other), Eco AntiVirus (other), MaCatte (other), Antivirus (other), Antivir (other), Personal Security (other).

2. Trojan:Win32/FakePowav– Aliases: Win Antivirus 2008 (other), SpyShredder (other), WinXProtector (other), Rapid Antivirus (other), Security 2009 (other), Power Antivirus 2009 (other), WinXDefender (other), SpyProtector (other), SpyGuarder (other), MSAntiMalware (other).

3. Program:Win32/MalwareBurn

4. Program:Win32/UnSpyPc

5. Program:Win32/DriveCleaner – Aliases: DriveCleaner (McAfee), W32/WinFixer.NU (Norman), DriveCleaner (Sunbelt Software), DriveCleaner (Symantec), Freeloa.8F4CBEAA (Trend Micro).

6. Trojan:Win32/DocrorTrojan

7. Program:Win32/Winfixer – Aliases: DriveCleaner (McAfee), W32/WinFixer.NU (Norman), DriveCleaner (Sunbelt Software), DriveCleaner (Symantec), Freeloa.8F4CBEAA (Trend Micro), Win32/Adware.WinFixer (ESET), not-a-virusownloader.Win32.WinFixer.o (Kaspersky), WinFixer (McAfee), Adware_Winfixer (Trend Micro), Program:Win32/DriveCleaner (other), Program:Win32/SecureExpertCleaner (other).

8. Trojan:Win32/FakeScanti – Aliases: Windows Antivirus Pro (other), Windows Police Pro (other), Win32/WindowsAntivirusPro.F (CA), FakeAlert-GA.dll (McAfee), Adware/WindowsAntivirusPro (Panda), Trojan.Fakeavalert (Symantec).

9. Program:Win32/Cleanator

10. Program:Win32/MalwareCrush

11. Program:Win32/PrivacyChampion

12. Program:Win32/SystemLiveProtect

13. Win32/Yektel

14. Trojan:Win32/FakeSmoke – Aliases: SystemCop (other), QuickHealCleaner (other), TrustWarrior (other); SaveArmor (other), SecureVeteran (other), SecuritySoldier (other), SafeFighter (other), TrustSoldier (other), TrustFighter (other), SoftCop (other), TRE AntiVirus (other), SoftBarrier (other), BlockKeeper (other), BlockScanner (other), BlockProtector (other), SystemFighter (other), SystemVeteran (other), SystemWarrior (other), AntiAID (other), Win32/WinBlueSoft.A (CA), Trojan-Downloader.Win32.FraudLoad.vtgpk (Kaspersky), WinBlueSoft (other), WiniBlueSoft (other), Winishield (other), SaveKeep (other), WiniFighter (other), TrustNinja (other), SaveDefense (other), BlockDefense (other), SaveSoldier (other), WiniShield (other), SafetyKeeper (other), SoftSafeness (other), SafeDefender (other), Trustcop (other), SecureWarrior (other), SecureFighter (other), SoftSoldier (other), SoftVeteran (other), SoftStronghold (other), ShieldSafeness (other).

15. Program:Win32/Spyguarder.A

16. Program:Win32/AntivirusGold

17. Program:Win32/SystemGuard2009

18. Program:Win32/WorldAntiSpy

19. Program:Win32/SpywareSecure – Aliases: W32/SpyAxe.AMI (Norman), SpywareSecure (Panda), SpywareSecure (Sunbelt Software), SpywareSecure (Symantec).

20. Program:Win32/IEDefender – Aliases: Win32/Burgspill.AD (CA), IEAntivirus (Symantec), Trojan.DR.FakeAlert.FJ (VirusBuster).

21. Program:Win32/MalWarrior

22. Program:Win32/Malwareprotector

23. Program:Win32/SpywareSoftStop

24. Program:Win32/AntiSpyZone

25. Program:Win32/Antivirus2008 – Aliases: Trojan.FakeAlert.RL (BitDefender), Win32/Adware.Antivirus2008 (ESET), not-a-virusownloader.Win32.FraudLoad.ar (Kaspersky), WinFixer (McAfee), W32/DLoader.HDZU (Norman), Troj/Dwnldr-HDG (Sophos), ADW_FAKEAV.O (Trend Micro), Program:Win32/VistaAntivirus2008.A (other), MS Antivirus (CA).

26. Trojan:Win32/PrivacyCenter – Aliases: Fake_AntiSpyware.BKN (AVG), Win32/FakeAV.ACR (CA), Win32/Adware.PrivacyComponents (ESET), not-a-virus:FraudTool.Win32.PrivacyCenter (other), not-a-virus:FraudTool.Win32.Agent.jn (Kaspersky), FakeAlert-CP (McAfee), Troj/PrvCnt-Gen (Sophos), SpywareGuard2008 (Symantec).

27. Program:Win32/SpyLocked

28. Program:Win32/Trojanguarder

29. Program:Win32/MyBetterPC

30. Program:Win32/NeoSpace

31. Win32/Winwebsec - Aliases: SystemSecurity2009 (other), System Security (other), Winweb Security (other), FakeAlert-WinwebSecurity.gen (McAfee), Mal/FakeAV-AK (Sophos), Troj/FakeVir-LB (Sophos), Adware/AntiSpywarePro2009 (Panda), Adware/UltimateCleaner (Panda), Adware/Xpantivirus2008 (Panda), Win32/Adware.SystemSecurity (ESET), Win32/Adware.WinWebSecurity (ESET), AntiVirus2008 (Symantec), SecurityRisk.Downldr (Symantec), W32/AntiVirus2008.AYO (Norman), Total Security (other), AntiSpyware Pro 2009 (other), FakeAlert-AntiSpywarePro (McAfee).

32. Trojan:Win32/FakeRemoc - Aliases: AntiMalwareSuite (other), VirusRemover2009 (other), PCAntiMalware (other), Total Virus Protection (other), SpywareRemover2009 (other), AntiMalwareGuard (other), Secure Expert Cleaner (other), Cleaner2009 Freeware (other), AVCare (other), AV Care (other).

33. Program:Win32/SpywareStormer

34. Program:Win32/SecurityiGuard

35. Program:Win32/DoctorCleaner

36. Program:Win32/UniGray

37. Win32/FakeSecSen – Aliases: Micro AV (other), MS Antivirus (other), Spyware Preventer (other), Vista Antivirus 2008 (other), Advanced Antivirus (other), System Antivirus (other), Ultimate Antivirus 2008 (other), Windows Antivirus 2008 (other), XPert Antivirus (other), Power Antivirus (other).

38. Program:Win32/VirusRemover – Aliases: Troj/FakeVir-DR (Sophos), VirusRemover2008 (Symantec), ADW_FAKEVIR (Trend Micro).

39. Program:Win32/Privacywarrior

40. Program:Win32/PrivacyProtector

41. Adware:Win32/SpyBlast

42. Trojan:Win32/FakeFreeAV

43. Win32/FakeRean - Aliases: XP AntiSpyware 2009 (other), XP Security Center (other), PC Antispyware 2010 (other), Home Antivirus 2010 (other), PC Security 2009 (other), ADW_WINREANIMA (Trend Micro), Win32/Adware.WinReanimator (ESET), not-a-virus:FraudTool.Win32.Reanimator (Kaspersky), WinReanimator (Sunbelt Software), XP Police Antivirus (other), FakeAlert-XPPoliceAntivirus (McAfee), Adware/XPPolice (Panda), AntiSpyware XP 2009 (other), Antivirus Pro 2010 (other).

44. Program:Win32/Antivirus2009 – Aliases: Win32/Adware.XPAntivirus (ESET), FakeAlert-AB.gen (McAfee), MalwareWarrior (other), Antivirus2009 (other).

45. Program:Win32/AntiSpywareDeluxe – Aliases: Adware.Fakealert-134 (Clam AV), Win32/Adware.AntiSpywareDeluxe (ESET), FraudTool.Win32.AntiSpywareDeluxe.a (Kaspersky), AntispyDeluxe (Symantec), TROJ_RENOS.CP (Trend Micro).

46. Program:Win32/Searchanddestroy

47. Program:Win32/AlfaCleaner

48. Program:Win32/WebSpyShield

49. Win32/InternetAntivirus – Aliases: InternetAntivirus (Symantec), General Antivirus (other), Personal Antivirus (other), not-a-virus:FraudTool:Win32.GeneralAntivirus.b (Kaspersky), Mal/FakeAV-AC (Sophos), TrojanDownloader:Win32/Renos.gen!Z (other), Fraudtool.GeneralAntivirus.C (VirusBuster), Internet Antivirus Pro (other).

50. Trojan:Win32/Antivirusxp – Aliases: Antivirus XP 2008 (other), Win32/Adware.WinFixer (ESET), Generic FakeAlert.a (McAfee), W32/WinFixer.BTB (Norman), Troj/FakeAV-AB (Sophos), AntiVirus2008 (Symantec), Program:Win32/Antivirusxp (other).

51. Program:Win32/ErrorGuard

52. Program:Win32/SpyCrush

53. Trojan:Win32/Fakeav

54. Program:Win32/Spyaway

55. Trojan:Win32/WinSpywareProtect – Aliases: Win32/Adware.WinSpywareProtect (ESET), Trojan-Downloader.Win32.FraudLoad.aob (Kaspersky), WinSpywareProtect (Symantec), Program:Win32/WinSpywareProtect (other), Trojan.FakeAV.GP (BitDefender), Win32/Adware.MSAntispyware2009 (ESET), Packed.Win32.Katusha.a (Kaspersky), FaleAlert-BV (McAfee), Adware/MSAntiSpyware2009 (Panda), Fraudtool.MSAntispy2009.A (VirusBuster), MS Antispyware 2009 (other), AV Antispyware (other), Extra Antivirus (other).

56. Program:Win32/Fakerednefed – Aliases: WinDefender 2008 (other), Program:Win32/Defendwin (other), Program:Win32/Windefender (other).

57. Program:Win32/Antispyware2008

58. Program:Win32/EZCatch

59. Program:Win32/EvidenceEraser

60. Program:Win32/Vaccine2008

61. Win32/FakeSpypro – Aliases: FakeAlert-C.dr (McAfee), SpywareProtect2009 (Symantec), Troj/FakeAV-LS (Sophos), Win32/Adware.SpywareProtect2009 (ESET), .Win32.FraudPack.kho (Kaspersky), Spyware Protect 2009 (other), Antivirus System Pro (other), Security Central (other), Barracuda Antivirus (other).

62. Trojan:Win32/FakeCog – Aliases: Win32/Adware.CoreguardAntivirus (ESET), not-a-virus:FraudTool.Win32.CoreGuard2009 (Kaspersky), FakeAlert-FQ (McAfee) , W32/Renos.FIP (Norman) , Mal/TDSSPack-L (Sophos), CoreGuardAntivirus2009 (Symantec), Fraudtool.CoreGuard2009.A (VirusBuster), CoreGuard Antivirus 2009 (other).

63. Program:Win32/AntiVirGear

64. Adware:Win32/VaccineProgram

65. Program:Win32/TrustCleaner

66. Program:Win32/SearchSpy

67. Program:Win32/AntiSpywareExpert – Aliases: Win32/Adware.AntiSpywareMaster (ESET), Generic.Win32.Malware.AntiSpywareExpert (other), WinFixer (McAfee), AVSystemCare (Symantec), AntiSpywareExpert (Trend Micro), not-a-virus:FraudTool.Win32.AntiSpywareExpert.a (Kaspersky).

68. Program:Win32/VirusRanger – Aliases: VirusRescue (Symantec) .

69. Program:Win32/SpyDawn

70. Program:Win32/UltimateFixer

71. Program:Win32/WinHound

72. Program:Win32/Spyshield

73. Program:Win32/SpySheriff – Aliases: Win32.TrojanDownloader.IEDefender (Ad-Aware), MagicAntiSpy (Sunbelt Software), Adware.SpySheriff (Symantec), SpyShredder (Symantec), IEDefender (other), Malware Destructor (other), SpySheriff (other), SpyShredder (other).

74. Program:Win32/Antispycheck – Aliases: Win32/Adware.AntiSpyCheck (ESET), AntiSpyCheck (Symantec).

75. Program:Win32/SpywareIsolator – Aliases: not-a-virus:FraudTool.Win32.SpywareIsolator.ad (Kaspersky), SpywareIsolator (Symantec).

76. Program:Win32/SpyFalcon

77. Program:Win32/PrivacyRedeemer

78. Trojan:Java/VirusConst

79. Trojan:Win32/FakeVimes – Aliases: FakeAlert-CQ (McAfee), Extra Antivirus (other), Ultra Antivirus 2009 (other), Malware Catcher 2009 (other), Virus Melt (other), Windows PC Defender (other).

80. Program:Win32/PCSave – Aliases: Win-Trojan/Pcsave.339456 (AhnLab), PCSave (McAfee).

81. Program:Win32/PSGuard

82. Program:Win32/SpywareStrike

83. Program:Win32/Nothingvirus

84. Trojan:Win32/AVClean

85. Trojan:Win32/FakeIA.C - Aliases: Win32/FakeAlert.RW (CA), Dropped:Trojan.FakeAv.DS (BitDefender), FakeAlert-AB (McAfee), Trojan.Fakeavalert (Symantec), not-a-virus:FraudTool.Win32.Delf.d (Kaspersky).

86. Program:Win32/AntispyStorm

87. Program:Win32/Antivirustrojan

88. Program:Win32/XDef

89. Program:Win32/AntiSpywareSoldier

90. Program:Win32/AdsAlert

91. Program:Win32/AdvancedCleaner – Aliases: AdvancedCleaner (Symantec).

92. Program:Win32/FakePccleaner - Aliases: Program:Win32/Pccleaner (other), Win32/Adwrae.PCClean (ESET), Backdoor.Win32.UltimateDefender.hu (Kaspersky), PCClean (Symantec), Program:Win32/UltimateCleaner (other).

93. Program:Win32/SpywareQuake

94. Program:Win32/WareOut – Aliases: WareOut (McAfee), W32/WareOut (Norman), WareOut (Sunbelt Software), SecurityRisk.Downldr (Symantec), Adware.Wareout (AVG).

95. Program:Win32/Kazaap

96. Program:Win32/SystemDefender

97. Trojan:Win32/FakeSpyguard – Aliases: Spyware Guard 2008 (other), Win32/Adware.SpywareGuard (ESET), FakeAlert-BM (McAfee), SpywareGuard2008 (Symantec), ADW_SPYWGUARD (Trend Micro), System Guard 2009 (other), Malware Defender 2009 (other).

98. Program:Win32/SpyHeal

99. Program:Win32/VirusBurst

100. Program:Win32/VirusRescue

101. Program:Win32/TitanShield

102. Program:Win32/Easyspywarecleaner

103. Trojan:Win32/Fakeinit – Aliases: Trojan.FakeAlert.AUW (BitDefender), Win32/FakeAV.ABR (CA), Fraudtool.XPAntivirus.BCVY (VirusBuster), Adware/AntivirusXPPro (Panda), AntiVirus2008 (Symantec), Advanced Virus Remover (other), Win32/AdvancedVirusRemover.G (CA).

104. Program:Win32/AntiVirusPro

105. Program:Win32/CodeClean

106. Trojan:Win32/Spybouncer

107. Program:Win32/MalwareWar

108. Program:Win32/VirusHeat

109. Adware:Win32/SpyAxe – Aliases: VirusHeat (other), ControVirus (other).

110. Program:Win32/Awola – Aliases: not-virus:Hoax.Win32.Avola.a (Kaspersky), Generic FakeAlert.b (McAfee), W32/Awola.A (Norman), Awola (Symantec), JOKE_AVOLA.D (Trend Micro).

111. Program:Win32/MyNetProtector

112. Program:Win32/FakeWSC

113. Program:Win32/DoctorAntivirus

114. Program:Win32/UltimateDefender – Aliases: Ultimate (McAfee), UltimateDefender (Symantec), ADW_ULTIMATED.ME (Trend Micro), Risktool.UltimateDefender.A.Gen (VirusBuster), Adware.UltimateX-15 (Clam AV), Win32/Adware.UltimateDefender (ESET).

ergent threats, etc.,” Wu stated.

With SP2 installed (XP Pro) - the control panel Function - Delete Programs -
has become mostly unusable ....

Symptoms: - the normal alphabetic and complete listing of the installed
programs now lists the programs

a) very partially - after the 'A"'s such as Adobe -- there is a long BLANK
scroll down before getting to the "F's" - with nothing (it's blank)
in-between showing
b) it's not a load timing function trime - i've been very patient
c) using display by other criteria show shows the same effect - however with
different programs (ie sort by size, dateg usage, etc).

What has happened here --- what has SP2 done - and how to correct it please.

The installation went smoothly - I've had no other problems - and indeed the
system seems to load and run faster.

Thanks in advance - Tiom


I've been a fairly happy camper with drawing in MSWord since Draw98. It does a reasonable job of encapsulating a drawing object, so as to be able to edit it in a separate context from the document as a whole, and then handling it as a block that can be trivially anchored and adjusted.

Word2000 didn't manage to include this "feature" (as far as I can tell), although Draw98 works just fine in Word2000. Alas, the objects added by Draw98 are not accessible to non-Draw98-enabled MSWord versions -- in particular Word2001 on the Mac. Which has become a serious problem for me, as I have to very regularly exchange MSWord documents with a Mac-enabled co-editor.

I suppose that all is wonderful in Word2002 (right?) and there is now an appropriate Draw Object which provides this encapsulation (if so, tell me about it!). But even if so, I'm still in Word2000, and currently need to stay there (mac compatibility being a serious concern; my co-editor isn't moving to OS X, needed for Office 2002).

The result is a really annoying sequence of actions apparently have to be performed every time I need to edit a drawing without using a Draw98 object. Surely there is a better way? Here's the sequence I currently have to perform to "get things right":

1. Edit the drawing in PowerPoint. Add a white-filled, no-border, background rectangle roughly the width of the page. Group everything.

2. WIth the cursor at the beginning of the Figure caption, cut-n-paste the grouped drawing into that spot.

3. Immediately right-mouse, select "format object", and then set the options as follows:

A. Select the Layout tab (if not already selected): set Square and Center
B. Select Advanced --> set Vertical position / absolute to zero
C. OK; OK.

That get's you the drawing in the right place (just above the caption), with its anchor on the caption line.

4. Then all of the text strings have picked up a default format (argh!), typically with a 5 pt "before spacing", so I have created a "Drawing Text" style without this -- which I then need to apply to each text string (else the strings will have "slid down" and become partially/mostly invisible/obscured).

With the Drawing Object encapsulation from Draw98, almost none of this necessary. In particular, WYSIWYG on the text, grouping is unnecessary in the drawing, the extra white background to force the object to be roughly page-width (else MSWord starts putting text on both sides which can't be otherwise stopped) is not needed, and the default setting on the "format object" are usually just what you want. Piece of cake.

Without Draw98, I have to repeat this entire process *every* time I make *any* edit to the drawing. Sheesh.

Perhaps I'm just being ill-informed about some less-than-obvious aspect(s) of Word2000, so please -- tell me how to get this simple (oughta be, right?) repetitive task to "work right".



Edited by HansV to display options in a table

I have two sets of radio buttons, each set in its own control box. Each selection in the first box has one or more eligible selections in the second box. The user must select one item in Box 1 and one item in Box 2 for the spreadsheet to work correctly. I currently list, in parentheses, the appropriate selections for Box 2 after each option in Box 1 (see below).

The problem is that some users are still confused about which options in Box 2 are eligible selections for the option selected in Box 1. I would like to highlight the eligible options in Box 2 depending on which option is selected in Box 1. Is there a way to do that?

Box 1Box 2Option 1 (A/[img]/forums/images/smilies/cool.gif[/img]Option AOption 2 (B/C)Option BOption 3 (A/C)Option COption 4 (B/D)Option DOption 5 (E)Option E
So, if Option 3 was selected in Box 1, Options A and C would become higlighted in Box 2.

Looking forward to hearing from you.


OK, I have a number of work sheets that have alpha characters in one cell in the row. What I would like to be able to do is to create a new row, that same as the original, but with only one of the alpha characters in it.

Say cell M2 has the values A, B, C (comma separated as shown), Cells A2 to L2 have various values in, I want to replicate cells A2 to L2 twice, so that I now have A2 to L2, A3 to L3, A4 to L4 all the same, then in M2, I have A, M3 would be B, M2 would be C.

I've been doing this so far by copy and paste, then deleting the extra characters, it has now become some what boring so I wondered if there was a clever way of doing it?

Thanks for reading, hope it makes sense.


My daughter had a homework question that I was unable to help her with. It involves making a scatter chart with a trend line. The data is given but I'm just not certain that I'm showing her the correct way...

Anyone care to offer a hand? I'd hate to give her bad information. Might lose my "good daddy" license. I've attached my attempt.

__________________________________________ __________________________________________


In a presidential election, a state's electoral votes go to the candidate who gets the most votes. The candidate who gets the greatest electoral vote becomes President. The number of electoral votes for each state, which is adjusted at each census, depends on its population.

a.) Make a scatter plot. Then draw a trend line.
b.) South Dakota is one of the states not listed in the table. It's population is about 700,000 people. Use the trend line to predict how many electoral votes South Dakota has.

Electoral Vote Data - 10 State Sample
Population (millions) 4 2 3 1 3 3 4 5 1 3
Electoral Votes 9 6 8 4 7 6 10 11 4 8


I need to calculate commision payable to members who are part of a multi level marketing scheme as follows. Each person that becomes a member has to introduce at least three new people and starts earning comm from person 3 onwards earns . The first 2 people that join at level 1 earns the person at the top of the level $0. The person on the top level earns $ 8 from person three onwards

if person A introduces persons B, C , D & F , person A will earn 2 x $8 . If Person C introduced persons G, H & I, person A will receive comm for Persons G & H .ie they move up the line to person and person C will receive Comm for person I

There is a maximum of three levels level 1 receives $8 per person in line 1 , level 2 receives $8 per person in their line, level 3 receives $4 per person in their line

I have also attached a document of how the scheme works

It would be appreciated if someone can help me set up a spreadsheet to calculate the comms



availble at www.Webjillion.com.
As described in today's NY Times:
PRODUCTIVITY TOOL Temptation Blocker - free, Windows-only software from Webjillion.com - blocks access to user-specified programs for a set time. B. Adam Howell created the tool as "a way for the smart part of me to head off the dumb, impulsive lizard part, and a way for me to get more stuff done at the computer."

"Have a major deadline looming or ripe opportunity closing and just don't have time to waste playing Half Life 2 or checking Bloglines one last time?" Mr. Howell asks. Just enter those programs, hit the "Get Work Done" button and computer games, Web browsers and other time-wasting programs become inaccessible. And no, you can't turn off Temptation Blocker until the restriction has elapsed.

Any comments or other suggestions?

Boris Jabes is fun guy to talk to about C++. He has the distinction of being the first guy to share the news about the removal of C++/CLI intellisense support in VC10. He also has a great perspective on why the decision was made and understands the complexity of intellisense projects and complex C++ projects in general. I wanted to talk to him about all this because I remember the customer outcry and the amount of respectful abuse poor Boris took (all in good stride, of course) from incensed programmers. Boris is a trooper and a strong advocate for the native development community using Visual C++.

After our discussion of intellisense in VC++, we move on to exploring game development in C++ and potential directions VC may take to make it easier to build high-performing, graphically rich games. Boris is a long-time Niner and the last time I interviewed him was in the Visual Studio 2005 timeframehe wanted to talk about C++/CLI, IDE tips and tricks, etc., and I kept asking questions about the C++ language (last comment on the post: "Charles seems so disinterested" LOL. Not true! Just wasn't thrilled about IDE stuff back then, that's all! ).

Welcome back to C9, Boris! It's always a treat to converse with you. Keep up the fantastic workthere's lots of dark matter out there that needs more light!

This is one of the typically open-minded-with-candor conversations with the C++ team that have become the norm here on C9 lately. True C9 Old School. Much thanks to the VC++ team for being so open and helpful, and for truly listening to what the VC++ community wants and needs.


Related links:

Boris' infamous post on rebuilding C++ intellisense and the hard decision that was made to remove intellisense support for C++/CLI for one release of VC++ => http://blogs.msdn.com/b/vcblog/archi...ellisense.aspx

Updated information from Tony Goodhew on the state of C++/CLI today and going forward in the next release of VC++ => http://blogs.msdn.com/b/vcblog/archi.../10136696.aspx

A younger Charles interviews Boris in 2005 =>http://channel9.msdn.com/Blogs/Charl...ips-and-Tricks (WMV only. Sorry about thatit's an old post!)


Today, we're introducing Vector. It's a blog about developers, platform, and big ideas/trends in tech, but with a little bit different bent on what folks are used to from Channel 9...
It's been eight years since Channel 9 first introduced many of our key engineering folks to the developer community to deliver a transparent view into how we think about the technologies we're working on, the teams doing the work, and the huge community of people in and around Microsoft that are connected to all of it. None of that changes ... the team continues to produce the great content that has personified Channel 9 since 2004. But we're also going to spend some time on a more 'elevated' view of what we're thinking when it comes to our own strategy, our competitors, broad-based industry stuff, and of course the intersection of all of this with business. Sometimes it'll be topical, other times it will just offer commentary on something that people are talking about. We will also have guest posters talking about what they're doing that fits in this vein.
So that brings us to an actual post on something meaningful ... the disruptive impact of the services model on businesses.
- The Channel 9 Team

In 2007, Nick Carr published "The Big Switch," which chronicles the evolution of electricity from being locally-generated by businesses on their factory floors to something we all now consume as a pay-for-what-you-use utility. The book draws parallels between electricity and packaged software as a means to offer up a potential end-state for cloud computing, hence the title ... there will be, the book asserts, a switchover from in-house datacenters to software delivered as a utility, and it's just a matter of time. It's a good book, not steeped in technical jargon but rather a set of thoughtful mappings between these two eerily similar eras of technology disruption.
Nearly five years have gone by since it was first published, and a lot has happened (and not happened) relative to the pace of cloud adoption ... we know a lot more about what motivates companies to push some apps out the door and into public clouds in a hurry, while other apps will take their time, or maybe even continue to run on-premises in so-called private cloud environments. So it begs a bunch of questions: What is the end state for the services disruption? Is it public cloud platforms and SaaS, or a hybrid of public and private cloud deployments, combined with traditional IT? In other words, is the big switch actually more of a dimmer switch, in the sense that it's not just a simple matter of on/off? Are there any other historical lessons or examples of disruption we can draw insight from?
Disruption is a great word ... if you talk to enough developers, IT folks, and industry pundits about services, "disruption" shows up as by far the most-used and (IMO) best descriptor for what's happening in computing today. Scenarios that used to be impractical, uneconomical, and just plain impossible are now fair game for developers to build and deliver, all because of increasingly cheap and abundant resources like compute, storage, and bandwidth, available at scale and on a pay-as-you-go basis. So when people talk about disruption, the shape of its impact on the market is generally assumed by most folks to be one of outright replacement, such as the advent of electricity as a utility, the combustion engine's replacement of the horse-drawn carriage, and digital media's disruption of physical media, to name a few - basically, the end state in which the disruptive technology means buggy-whip obsolescence for the existing technology. But not all disruptions play out this way, and there are more than a few historical examples, my personal favorite being the captivating story of the microwave business. Seriously, it's actually pretty interesting ...
So here's the story (courtesy of Wikipedia):
As we all know, atomic research started in the 1940's for military purposes, but one of the offshoots of it was the discovery that you could actually use microwave radiation to heat food. Like most technology disruptions (including cloud computing), the discovery & development pre-dated mass adoption by many years. In the case of the microwave, the earliest patents were filed by Raytheon just after World War II, and were licensed to Tappan for the first home-use microwave. It was introduced in 1955 and cost over $1,000, but not surprisingly it didn't do well in the market. Raytheon got back into the game by acquiring Amana and introducing the Radarange in 1967 for about $500, and that's really where market adoption began to take shape. In 1971, 1% of US households owned a microwave, and by 1986 it was 25%, and today it's over 90%.
What's interesting here is how the adoption curve was shaped based on the market's education on what you could and couldn't do with this thing. Keep in mind that the value prop of the microwave was time-savings for the subset of cooking tasks for which the new technology could be used. Can you bake a cake with a microwave? They're not ideal for that. Can you thaw out frozen stuff? Yeah, it's great for that. What about broiling a salmon? Well, no. How about reheating leftovers? Yeah, it's perfect for that. Why do sparks fly everywhere when I put metal in it? You should really read the owner's manual. This was all part of what could best be described as a partitioning process ... partitioning what you do in a kitchen between the existing thing and the new thing. How was this process accelerated? It was just outright education, in many cases through print and TV advertising, which were rife with "ideas" about what you could actually cook, but also by shipping microwave cookbooks with the actual units. Some of the recipe ideas were a stretch (Thanksgiving turkey in a microwave?), but over time, people figured it out and knew what they should and shouldn't be cooking with it, and that essentially determined the end state for the disruptive technology: every modern kitchen will generally have both a conventional oven and a microwave.
So what can we learn from this? Allowing for the fact that the oven business and computing are two entirely different animals, the biggest and most obvious parallel is the ongoing education of the market that we're seeing now about which apps are and are not necessarily well-suited to public cloud deployment. In other words, within any business' app portfolio, there are no-brainers for cloud deployment (web workloads, email, collab, CRM, test, HPC, etc.), while other apps and workloads are subjected to more scrutiny, at least for the time being (ERP, mission-critical apps, apps with HBI data, etc.). Every business, no matter how small, has a portfolio of apps, and this process of portfolio portioning is pretty similar to the task-partitioning process that shaped microwave adoption. In the software industry, we see this in business scenarios, in which there's a lot of focus these days on things like PII at massive scale, infrastructure security, data sovereignty, the regulatory environment, and a host of other factors that business folks consider as part of the go/no-go decision on cloud computing.
At any rate, the end state is becoming increasingly clear: businesses end up with a mixed bag of delivery and deployment approaches to deal with the variable needs & complexities of each & every app in their respective portfolios, at least for the foreseeable future. If you pay attention to cloud computing rhetoric in the industry, hybrid cloud is the new black, but for our part, but the answer was there all along. There's an obvious tension between the possibilities afforded by what is arguably the biggest shift in our industry since the advent of client/server, and the practical realities of technology change for businesses that are grappling with this new era of computing. But from a technical strategy standpoint, there is no confusion on our part ... the design point that defines cloud computing is the path forward for app dev: the next set of apps that matter will be designed for scale and elasticity. They'll be resilient, multi-instance, and highly available. Everything we're doing in the platform across Windows Azure and Windows Server is geared toward enabling developers to meet this design point with the new apps they're building.
This means that today's great debate is twofold: a.) where will these new apps run? And b.) where will those existing apps end up? Off-prem in the cloud, or on-prem in the data center? The answer is "yes." And that's really the point ... the discussion about *where* the apps run (and what most people fixate on when they talk about the services disruption) is orthogonal to the discussion about whether it's an app that meets the bar for the cloud design point vs. an n-tier app running in a VM that's really yesterday's design point. Most businesses' portfolio of apps will have both kinds, old school and new school, and they'll be partitioned across off-prem and on-prem. Cloud adoption in big companies still has a ways to go, but even in these early days, the emerging trend line is becoming increasingly clear. Nick Carr even called this one in the "Big Switch", in the form of this excerpt from pg. 118...
"...larger companies...can be expected to pursue a hybrid approach for many years, supplying some hardware and software requirements themselves and purchasing others over the grid. One of the key challenges for corporate IT departments, in fact, lies in making the right decisions about what to hold on to and what to let go."The idea that app portfolios will be partitioned in this way seems pretty intuitive to the folks that are grappling with the change, at least based on the customer discussions we're having these days. To be clear ... the cloud design point is, without a doubt, what we're headed toward with a new generation of apps that are going live in increasing numbers every day (and the subject of a future post), but their place in the broader business app portfolio makes it's trajectory more akin to a dimmer that's turned up over time than a simple on/off.
Thanks for listening comments & feedback welcome.


Hey, Net Neutrality: Why Not Try Freedom?
Campaign For Liberty; Hey, Net Neutrality: Why Not Try Freedom?
(Please note that this is a political OP-ED, so it is going to be very one sided on the subject, but an interesting observation and discussion none-the-less)

Net Neutrality is a proposal for the federal government to take ownership of internet service provided and owned by private corporations because they believe that they are the best at protecting freedom of speech. This ironic statement is sad when you consider the federal government's recent role of suppressing the freedom of speech such as;

(a) Three years ago in Morse v. Frederick the U.S. Supreme Court held that public schools have the authority to tell students what types of signs they can hold on their own private property (2007) [1].
(b) In direct opposition to the freedom of speech the federal government purchased Long Range Acoustic Devices (LRAD) from American Technology Corporation for the G20 Summit in Pittsburgh, which lead to riot police using their new weapon for the first time on humans, the arrests of hundreds of innocent civilians, and physical attacks to students at the University of Pittsburgh- all to prevent peaceful protesting with political dissent (2009)[2] [3].
(c) Senator Jay Rockefeller is drafting and proposing bills in congress that give the federal government control over thousands of private corporations' property and state that the president can "declare a cyber security emergency" and completely disconnect everyone from the internet (2009) [4].

In 2008 the U.S. Federal Communications Commission (FCC) ordered the internet service provider Comcast to stop their network management strategy, under the guise of what they call an "open internet" [5]. Unfortunately there is nothing "open" about it, as it further inhibits competition and is designed to give the federal government more control over the internet and service providers.

The Comcast Corporation wants to implement their "congestion management practices" which include; manipulating bandwidth allocation to lower the priority of subscribers who use more bandwidth [6]. Many people believe this practice will lead to Comcast filtering and prioritizing data and bandwidth to their advantage in order to suppress the freedom of speech and to gain a more competitive advantage in other business ventures. For example Comcast might provide faster access to their recently acquired MSNBC website and may slow down access to competitors such as; Fox, ABC, CNN and other alternative news websites such as infowars.com.
Many people and organizations such as the FCC believe that it is the role of government to take an authoritarian approach and command others what to do with their own private property in order to protect freedom, however one has to take into account that Comcast has invested millions of dollars into running physical cables throughout 39 out of 50 states including the District of Colombia, and if the FCC were to block them from selling their own services how they see fit; it would be essentially robbing them of their investment. Even though Comcast may be acting unethical if they do resort to the practice of filtering data; stealing from them is not the sensible, ethical response. There are few practices less logical than; We don't want you to do anything unethical, so we are going to steal from you. However, when one learns the real reason why Comcast is able to propose these strategies, the entire issue becomes moot.

It is popular belief that only legal regulation can stop monopolies, but top experts in the specific field of monopolies and antitrust acts such as; Professor of Economics at Hartford University Dominick T. Armentano author of Antitrust & Monopoly, disagree completely and state that not only does regulation create monopolies; the only way to stop one is with the power of a free market [7]. Unfortunately the United States hasn't experienced a truly free market in roughly 100 years, and the majority of the population confuses the term with corporatism. Corporatism is defined as corporations working in coalition with government entities such as a city or state, a free market is defined as an economy based on supply and demand with little or no government intervention [8] [9].
In most cities and towns throughout the United States an individual has very limited options with regards to high speed internet service providers, there is often only one service provider offering Cable (~3-12mbs) and another offering DSL (~1-3mbs). This by definition is a monopoly on the market, and it is common in most municipalities for the city or town to have an agreement with these service providers- effectively suppressing free market competition. It does not take a computer scientist to realize the potential unethical behavior that can result from a corporation having a monopoly on a service with high importance such as the internet, especially when they have private agreements and protection from local governments. This is corporatism and is the real source of the problem.

The basic fundamentals of economics in supply and demand state that when a corporation is not providing services that the public wants, there is an excellent opportunity for a new corporation to step in and fill the gap. The only reason why Comcast can even speculate implementing this strategy is because they know they have a complete monopoly in their market. If there was competition there ready to fill in the gap giving consumers a choice between filtered traffic and freedom, Comcast would not dare to promote anything less than a completely free and open internet, else they would naturally lose a lot of business to their competitors.
If one takes a look 5,000 miles to the east you may see Japan; currently the home of one of the world's fastest, most free, internet services, offering Fiber To The Home (FTTH) in over 30 million homes all over the country [10]. One can currently obtain a connection to their home with speeds of up to 1,024Mbs for less than $50/month, compared to Comcast which offers ~12Mbs. 1024Mbs is a max upload/download speed of 128 Megabytes per second, so theoretically one could download an entire DVD worth of data from across the country in ~36 seconds, compared to more than 3 hours from the current Cable/DSL providers. The average size of a web page is 130KB that means that in Tokyo you can download and view a web page in just over 1 millisecond or ~1,000 web pages in one second.

How is this possible in Japan? Free market competition; there are currently numerous companies that provide the service of just running these cables directly to your home, compared to the only one company in the cities and towns all over the United States. Then there are dozens of separate service providers that manage your connection to the internet, compared to options in the U.S. where the same company that runs the lines offers the service. A service provider in Japan would not dare publicly discuss such tactics as Comcast's congestion management practices, because they would instantly be boycotted and crushed by their competition. This is fundamental economics in a free market society.

4 Providers in the U.S. - Corporatism [11] 24 Providers in Japan - Free Market [12]
Everyone that wants better, faster, and more freedom in internet service should NOT be screaming Net Neutrality, they should be screaming Free Market. How do current service providers have monopolies in their market? Is it because they are the only companies in the entire country capable of offering internet services? Absolutely not, it is because of corporatism and the many local towns and municipalities that work out private agreements with current service providers, effectively creating and ensuring the permanent sustainability of these monopolies. This type of strategy belongs in a socialist country, not the United States; for how can liberty prevail in a society where governments cater to only one specific special interest?
If politicians are serious about a long-term permanent solution to continuously provide a real "open internet", the only answer is to influence these municipalities into adopting a free market system and promote competition. Keeping the market closed and discriminating against other corporations that want to compete, will only further propagate monopolies and ultimately suppress not just the freedom of speech, but also the American Dream that the free market provides.

By Chester Gould for the John Dennis 2010 Campaign:

Original Article: Hey, Net Neutrality: Why Not Try Freedom? | Defeat Pelosi > John Dennis 2010

For //build/ 2012, we wanted to showcase what Windows 8 can offer developers. There are a lot of projects showing off great things like contracts and Live Tiles, but we wanted to show off some of the lesser known features. This project focuses on one of those: stereoscopic 3D with DirectX 11.1.
Prior to DirectX 11.1, stereoscopic 3D required specific hardware and a custom API written for that hardware. With DX11.1, stereoscopic 3D has been "democratized." Any GPU that supports DirectX 11.1 can be connected to any device which supports stereoscopic 3D, be it a projector, an LCD TV, or anything else. Plug it in and DirectX does the rest.
From the software side of things, any DX11.1 application can determine if the connected display supports stereoscopic 3D, and choose to render itself separately for the player's left and right eye.
To showcase this feature, we decided to build a very simple game that would give the illusion of depth, but be easy to explain and play. What's easier than Pong? So, we built the world's most over-engineered game of 3D Pong named Maelstrom.


Each player setup consists of two applications: the DirectX 11.1 game written in C++, and the touch-screen controller written in C#/XAML. Both are Windows Store applications. Since this is a two player game, there are two instances of each application running, one per player. All for applications are networked together using StreamSockets from the Windows Runtime. The two controllers and player two's DirectX game connect to player one's DirectX game, which acts as the "master". Controller input is sent here, and, once the ball and paddle positions are calculated, the data is drawn for player one and sent to player two which draws the world from the other player's perspective.

Direct3D Application

Getting Started with stereoscopic DirectX11, C++, and XAML

If you have never worked with DirectX before, it can be a little overwhelming at first. And even if you have worked with it some in the past, targeting the new Windows 8 ecosystem, along with C++ and XAML have added some additional changes in how you may have designed your solution previously.
Fortunately, the Windows Dev Center for Windows Store Apps has some great samples to get you started, and we took full advantage of them to get to speed. For a great, simple example of how to leverage the new stereoscopic feature in Direct3D 11.1, we started with Direct3D Stereoscopic Sample which shows the basic adjustments to the Render loop for toggling your virtual cameras. However, to see a great example of a simple game structure that also leverages stereoscopic rendering where available, the tutorial found at Walkthrough: a simple Windows Store game with DirectX is invaluable. Further in this article, we will dive deeper into the specifics of stereoscopic rendering in our game.
One thing to note, if you follow the link in the above Walkthrough to the original project, it will take you to a C++ only implementation of the game. Now, of course, all the DirectX game objects such as the paddle, puck and walls are all rendered using D3D. However, for HUD (Heads up Display) elements, this C++ only sample also uses DirectX exclusively. If you are coming from a managed code background, this will definitely seem like unnecessary overhead. That is because this C++ only sample was created after last year's BUILD conference in 2011 and C++ and DirectX still did not play well with XAML.
However, a few months later, the ability to nest DirectX content in a XAML project became available for true hybrid style solutions (see the article DirectX and XAML interop - Windows Store apps using C++ and DirectX for more information). After this feature was added, the simple Shooter Game referenced above had its HUD logic rewritten in XAML and posted up to Dev Center as XAML DirectX 3D shooting game sample, which shows both stereoscopic support, a simple Game Engine structure in C++ and XAML integration. At this point, we had all the starter code we needed to start writing our own game.
Game Engine

We modified the base sample to accommodate our needs. We created specific GameObjects, such as Paddle, Puck, etc. to add the behaviors we needed. We also added an Update and Render method to the base GameObject so that, for every frame, we could do any calculations required, and then draw the object to the screen. This is very similar to how XNA sets up its game engine.
Game Constants

Because we were tweaking a variety of values like colors, sizes, camera locations, etc., we created a GameConstants.h header file which contains nothing but these types of values in a single location. This made it very easy for us to quickly try out various tweaks and see the results on the next run. Using namespaces helped keep the code a bit more manageable here as well. Heres a quick snippet of that file:

namespace GameConstants{ // bounds of the arena static const DirectX::XMFLOAT3 MinBound = DirectX::XMFLOAT3( 0.0f, 0.0f, 0.0f); static const DirectX::XMFLOAT3 MaxBound = DirectX::XMFLOAT3(19.0f, 10.0f, 90.0f); // game camera "look at" points static const DirectX::XMFLOAT3 LookAtP1 = DirectX::XMFLOAT3(9.5f, 5.0f, 90.0f); static const DirectX::XMFLOAT3 LookAtP2 = DirectX::XMFLOAT3(9.5f, 5.0f, 0.0f); // Waiting Room camera positions static const DirectX::XMFLOAT3 WaitingEyeP1 = DirectX::XMFLOAT3(GameConstants::MaxBound.x/2, GameConstants::MaxBound.y/2, GameConstants::MaxBound.z - 12.0f); static const DirectX::XMFLOAT3 WaitingEyeP2 = DirectX::XMFLOAT3(GameConstants::MaxBound.x/2, GameConstants::MaxBound.y/2, GameConstants::MinBound.z + 12.0f); static const DirectX::XMFLOAT3 WaitingEyeMjpegStation = DirectX::XMFLOAT3(GameConstants::MaxBound.x/2, GameConstants::MaxBound.y/2, GameConstants::MinBound.z + 9.6f); // game camera eye position static const DirectX::XMFLOAT3 EyeP1 = DirectX::XMFLOAT3(GameConstants::MaxBound.x/2, GameConstants::MaxBound.y/2, GameConstants::MinBound.z - 6.0f); static const DirectX::XMFLOAT3 EyeP2 = DirectX::XMFLOAT3(GameConstants::MaxBound.x/2, GameConstants::MaxBound.y/2, GameConstants::MaxBound.z + 6.0f); static const float Paddle2Position = MaxBound.z - 5.0f; namespace PaddlePower { // power level to light paddle at maximum color static const float Max = 9.0f; // max paddle power color...each component will be multiplied by power factor static const DirectX::XMFLOAT4 Color = DirectX::XMFLOAT4(0.2f, 0.4f, 0.7f, 0.5f); // factor to multiply mesh percentage based on power static const float MeshPercent = 1.2f; }; // time to cycle powerups namespace Powerup { namespace Split { static const float Time = 10.0f; static const float NumTiles = 4; static const DirectX::XMFLOAT4 TileColor = DirectX::XMFLOAT4(0.1f, 0.4f, 1.0f, 1.0f); static const float TileFadeUp = 0.20f; static const float TileDuration = 2.10f; static const float TileFadeDown = 0.20f; static const float TileMeshPercent = 2.0f; static const float TileDiffusePercent = 2.0f; }; };}Stereoscopic 3D

Direct3D must be initialized properly to support stereoscopic displays. When the swap chains are created, an additional render target is required, such that one render target is for the left eye, and one render target is for the right eye. Direct3D will let you know if a stereoscopic display is available, so you can create the swap chain and render targets appropriately.
With those in place, its simply a matter of rendering your scene twice, once per eyethat is, once per render target.
For our game this was very simple. Our in-game camera contains two projection matrices, one representing the view from the left eye, and one from the right eye. These are calculated when the projection parameters are set.

void Camera::SetProjParams( _In_ float fieldOfView, _In_ float aspectRatio, _In_ float nearPlane, _In_ float farPlane ){ // Set attributes for the projection matrix. m_fieldOfView = fieldOfView; m_aspectRatio = aspectRatio; m_nearPlane = nearPlane; m_farPlane = farPlane; XMStoreFloat4x4( &m_projectionMatrix, XMMatrixPerspectiveFovLH( m_fieldOfView, m_aspectRatio, m_nearPlane, m_farPlane ) ); STEREO_PARAMETERS* stereoParams = nullptr; // Update the projection matrix. XMStoreFloat4x4( &m_projectionMatrixLeft, MatrixStereoProjectionFovLH( stereoParams, STEREO_CHANNEL::LEFT, m_fieldOfView, m_aspectRatio, m_nearPlane, m_farPlane, STEREO_MODE::NORMAL ) ); XMStoreFloat4x4( &m_projectionMatrixRight, MatrixStereoProjectionFovLH( stereoParams, STEREO_CHANNEL::RIGHT, m_fieldOfView, m_aspectRatio, m_nearPlane, m_farPlane, STEREO_MODE::NORMAL ) );}Depending on which eye we are rendering, we grab the appropriate projection matrix and pass it down to the vertex shader, so the final scene is rendered offset for the proper eye.
Collision Detection

If you are just starting to move into 3D modeling and programming, one of the trickier aspects of your game can be collision detection and response. Maelstrom uses primitives for all of the game elements, so our collision code was able to be a bit more straightforward compared to complex mesh collisions, but understanding a few core math concepts is still critical to grasp what the code is doing.
Fortunately, DirectX provides us with an DirectX Math Library that is able to do the serious heavy lifting, so the main complexity comes from framing the problem and learning how to apply the library.
For example, In our situation we had up to three very fast moving spheres and needed to check for wall collisions and then handle to appropriate bounce, since some of the walls would also be angled. In a 2D game, a collision detection between a sphere and an axis line is very easy. If the distance between a circle and the line is less than or equal to the radius of the sphere, they are touching. On every frame, you move your circle based on its velocity and do your collision test again. But even here, your solution may not be that easy for two reasons.
First, what if the line is angled and not lying flat on the X or Y axis? You have to find the point on the line based on the line's angle that is closest to the sphere to do your distance calculations. And if you then want it to bounce, you have to rotate the velocity of the circle by the line's angle, calculate your bounce, and then rotate back. And that's just rotated walls in 2D. When you move up to 3D, you have to take into account the surface normal (which way the 3D plane is facing) in your calculations.
The second complexity that we needed to account for and which pops up in either 2D or 3D collision detection is travel between frames. In other words, if your ball is travelling very fast, it may have completely travelled through your collision boundary in between frames and you wouldn't notice it if you are only doing a distance / overlap check as outlined above. In our case, the pucks had the ability of travelling very fast with a speed boost, so we needed a more robust solution. Therefore, instead of implementing a simple sphere plane intersection test, we needed to create a line of motion that represented where the ball ended on the previous frame and where it currently is after it's new velocity is added to it's position. That line then needs to first be tested to see if it crosses a WallTile. If it does cross, then we know an collision has occurred between frames. We then solve for the time (t) between frames the Sphere would have first made contact to know the exact point of impact and calculate the appropriate "bounce off" direction.
The final code for a puck (or moving sphere) and wallTile collision test looks like this:

bool GameEngine::CheckWallCollision(Puck^ puck){ bool isIntersect = false; bool wallCollision = false; for(unsigned int i = 0; i < m_environmentCollisionWalls.size(); i++) { WallTile^ wall = m_environmentCollisionWalls[i]; float radius = puck->Radius(); float signedRadius = puck->Radius(); float contactTime = 0.0f; XMVECTOR contactPlanePoint = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f); XMVECTOR contactPuckPosition = XMVectorSet(0.0f, 0.0f, 0.0f, 0.0f); bool intersectsPlane = false; // Determine the velocity of this tick by subtracting the previous position from the proposed current position. // in the previous update() cycle, puck->Position() = puck->OldPosition() + ( puck->velocity * timerDelta ). // Therefore, this calculated velocity for the current frame movement differs from the stored velocity // since the stored velocity is independent of each game tick's timerDelta. XMVECTOR puckVectorVelocity = puck->VectorPosition() - puck->OldVectorPosition(); float D = XMVectorGetX( XMVector3Dot( wall->VectorNormal(), wall->VectorPosition() ) ); // Determine the distance of the puck to the plane of the wall. float dist = XMVectorGetX( XMVector3Dot(wall->VectorNormal(), puck->OldVectorPosition() )) - D; signedRadius = dist > 0 ? radius : -radius; // if the distance of the puck to the plane is already less than the radius, the oldPosition() was intersecting already if ( fabs(dist) < radius ) { // The sphere is touching the plane. intersectsPlane = true; contactTime = 0.0f; contactPuckPosition = puck->OldVectorPosition(); contactPlanePoint = puck->OldVectorPosition() + wall->VectorNormal()*XMVectorSet(signedRadius,signedRadius,signedRadius,1.0f); } else { // See if the time it would take to cross the plane from the oldPosition() with the current velocity falls within this game tick. // puckVelocityNormal is the amount of force from the velocity exerted directly toward the plane. float puckVelocityNormal = XMVectorGetX(XMVector3Dot(wall->VectorNormal(), puckVectorVelocity )); // if the puckvVelocityNormal times the distance is less than zero, a plane intersection will occur if ( puckVelocityNormal * dist < 0.0f ) { // determine the contactTime, taking into account the shell of the sphere ( position() + radius ) // is what will make contact, not the position alone. contactTime = (signedRadius - dist) / puckVelocityNormal; // if the contact time is bewteen zero and one, the intersection has occured bewteen oldPosition() and position() if ( contactTime > 0.0f && contactTime < 1.0f ) { intersectsPlane = true; // this is the position of the puck when its shell makes contact on the plane contactPuckPosition = puck->OldVectorPosition() + XMVectorScale(puckVectorVelocity, contactTime); // this is the position on the plane where the shell touches. contactPlanePoint = contactPuckPosition - XMVectorScale(wall->VectorNormal(), signedRadius); } } } // If the puck has contacted the wall plane, determine if the point of contact falls within the wall boundary for true contact. if (intersectsPlane) { float Kr = 1.0f; // Kr is the coefficient of restitution. At 1.0, we have a totally elastic bounce with no dampening. At Kr = 0.0, the ball would stop at the wall. // Make sure the puck velocity and wall normal are facing each other float impact = XMVectorGetX ( XMVector3Dot ( wall->VectorNormal(), puck->VectorVelocity()) ); if (impact < 0.0f) { wallCollision = true; //// bounce the vector off the plane XMVECTOR VectorNormal = XMVector3Dot(wall->VectorNormal(), puck->VectorVelocity())*wall->VectorNormal(); XMVECTOR VectorTangent = puck->VectorVelocity() - VectorNormal; puck->Velocity(VectorTangent - (XMVectorScale(VectorNormal, Kr))); puck->Position(contactPuckPosition); int segment = (int)(puck->Position().z / GameConstants::WallSegmentDepth); segment = max(min(segment, GameConstants::NumWallSegments-1), 0); auto tiles = m_wallTiles[segment]; WallTile^ tile = tiles[i]; if(tile->GetPowerup() == Powerup::Split) SplitPucks(); break; } } } return wallCollision;}Drawing Maelstrom

To draw the game, we wanted to use some advanced techniques. We decided to go with a light pre-pass deferred rendering pipeline with normal mapping. Thats a lot of jargon but it isnt all that complicated once you know what the jargon means, so lets break it down.
When you draw something in 3D, there are three things that come together to determine the final color of each pixel on the screen: meshes, materials, and lights. A mesh is a collection of triangles that make up a game object (such as a wall tile in Maelstrom). On its own, a mesh is just a bunch of dots and lines. A material makes a mesh look like something. It could be as simple as a solid color but usually its a texture and sometimes its more (the wall tiles in Maelstrom use both a texture and a normal map to define their material properties). Lastly, lights transform materials by determining how bright they should appear and what sort of tint, if any, they should have. Without lights you would either have complete darkness or you would have flat lighting (where everything has a uniform brightness and adding a tint color would uniformly tint everything on the screen).
Forward Rendering vs. Deferred Rendering vs. Light Pre-Pass Rendering

The simplest approach to drawing 3D graphics is something called forward rendering. With forward rendering, drawing consists of rendering the mesh and calculating its material and all the lights that affect the material all at the same time. The more lights you add, the more complicated your shaders become since you have to determine whether each light affects the material and if so how much. (Ok, so theres also multi-pass forward rendering, but that has its own problems more passes mean longer render times and thus a lower frame rate and we wanted to keep the descriptions simple).
In the last 5 years, many games started using a technique called deferred rendering. In classic deferred rendering, there are two rendering passes. The first pass renders the positions, normals, and material values of all the meshes in the scene to something called a G-Buffer (two or more render targets); nothing is actually drawn to the screen in this first pass. The second pass uses the data from the G-Buffer (which tells us everything we need to know about the geometry that appears at each screen pixel) and combines it with the lights to create the final image that you see. By doing this, we decouple geometry and lighting. This makes it possible to add more lights to the scene with a much smaller performance impact than in forward rendering since we dont need to create a really complex pixel shader to handle all the lights (single-pass forward rendering) or draw the geometry over and over again for each light (multi-pass forward rendering).
There are drawbacks to classic deferred rendering though. Even a minimal G-Buffer takes up quite a bit of memory and the more different types of materials you want to support, the larger the G-Buffer will need to be. Wolfgang Engel, an XNA/DirectX MVP, came up with a variation on deferred rendering which he called Light Pre-Pass Rendering. This is a three pass technique. We once again use a G-Buffer, but in this case it is smaller than the classic deferred rendering G-Buffer and can even be squeezed down to a single render target which makes it viable for graphics hardware which does not support drawing to multiple render targets at the same time.
The G-Buffer is created in the first pass by rendering all the scene geometry. It only needs to store normals and the geometrys world position. We stored the world position of the geometry at that screen position in one render target and its normal at that screen position in second render target for simplicity.
The next pass draws the lights to a light accumulation buffer. The buffer starts out entirely dark and each light that is rendered adds brightness (and tint, if any) to the light buffer. These lighting calculations take into account the normal and world position of the geometry that is at each screen position, drawing the values from the G-Buffer, such that each light only affects the pixels it is supposed to have an impact on. In Maelstrom we ended up only using point lights (spheres of light that fade out as you get further from the lights position), but you can use any kind of light you can imagine (spot lights and directional lights are the two other common light types). Adding more lights has a very low impact on rendering time and this kind of lighting tends to be much easier for the designer to work with since theres no need for him or her to understand HLSL or even any complicated C++ in order to add, remove, reposition, or otherwise change any lights.
The final pass draws the geometry a second time. This time, though, all the lighting calculations are done so all we do here is just render the meshes with their appropriate materials, adjust the color values and intensities from the material based on the light buffer value, and were done. Each rendering style (forward, deferred, and light pre-pass) has its own benefits and drawbacks, but in this case light pre-pass was a good solution and choosing it let us show how a state-of-the-art graphics technique works.
Normal Mapping

We also incorporated normal mapping. Normal mapping makes us of a special texture (a normal map) in addition to the regular texture that a material has. Normals are values used in lighting calculations to determine how much a particular light should affect a particular pixel. If you wanted to draw a brick wall, you would typically create two triangles that lined up to form a rectangle and you would apply a texture of a brick wall to them as their material. The end result of that doesnt look very convincing though since unlike a real brick wall there are no grooves in the mortared area between each brick since our brick and mortar is just a flat texture applied to flat triangles. We could fix this by changing from two triangles to a fully modeled mesh with actual grooves, but that would add thousands of extra vertices which would lower the frame rate.
So instead we use a normal map, which fakes it. One of the reasons that the two triangles + a brick wall texture approach doesnt look right is because the lighting doesnt behave correctly when compared to a real brick wall (or to a fully modeled mesh of a real brick wall). The normals point straight out perpendicular from the face of the rectangle whereas if we had the fully modeled mesh with actual grooves, the surface normals would only point straight out on the bricks themselves and they would curve along the mortared areas such that the lighting calculations would end up giving us the right levels of light and dark depending on the location and direction of the light. Thats where a normal map comes in. The normal map (which you can generate using a plugin for Adobe Photoshop or GIMP or by modeling a real brick wall in 3DSMax, Maya, or Blender which you then bake a normal map from) allows us to get the same lighting effect as we would with a fully modeled mesh while still keeping the simple two triangle + a brick wall texture approach that gives us really good performance for our game. There are limits to the effectiveness of normal mapping (you cant use it to fake anything too deep and it doesnt hold up as well if the camera can get really close to the object) but in Maelstrom it allowed us to keep the walls as simple triangles (like the two triangles + a brick wall texture example above) while making it seem like there were geometric grooves in the wall. Heres a before and after screenshot using normal mapping:

Post-Processing Effects

We also used several post-processing effects. The first was the bloom effect. Bloom is an effect that analyzes a rendered image, identifies parts that are above a certain brightness threshold, and makes those areas brighter and adds a peripheral glow to them as well, giving it a look and feel that is similar to a neon sign or to the light cycles in the movie Tron. Heres the same shot as above with the addition of bloom:

We also made use of two different damage effects. Whenever the player took damage, we had a reddish tinge around the edge of the screen. This was simply a full screen overlay texture that is actually white but is tinted red by the shader. It is alpha-blended over the final rendered scene and fades out over the course of a couple of seconds. Rather than fading out linearly, we use a power curve which helps to sell the effect as being more complicated than it really is.
Lastly we added in some damage particles. The particles themselves were created using a geometry shader. The vertex shader took in a series of points in world space and passed these points along to the geometry shader. The geometry shader expanded these points into two triangles by generating the missing vertices and applying the world-view-projection transformation matrix to transform the positions from world coordinates to homogeneous coordinates so that they can then be rasterized correctly by D3D and the resulting pixels passed along to the pixel shader. Once again we used a simple texture with alpha blending to simulate much more complicated geometry than we were actually drawing. In this case we also made use of a texture atlas (an image made up of smaller images) which, in conjunction with the randomizer we used to generate the initial vertices for the particles, allowed us to have several different particle textures. Like with the power curve for the damage texture, the texture atlas allowed us to make the particles seem more complex than they really were. It also let us show off the use of a geometry shader, a feature that was added in DirectX 10 and requires DirectX 10 or higher hardware.

All audio was done using the XAudio2 API. Thankfully, we were able to get a huge head start by using some of the code from the sample project we started from. The audio engine sets up the very basics of XAudio2, and then wraps that with a simpler API for the rest of the application to call.
We dont have many sound effects, so we on startup, we load all sounds effects and music cues into a std::map, keyed on a SoundCue enum. Sounds are loaded using the Media Foundation classes, and the resulting byte data of the sound (and some format information) are stored in our SoundEffect class.

void AudioEngine::Initialize(){ m_audio = ref new Audio(); m_audio->CreateDeviceIndependentResources(); m_mediaReader = ref new MediaReader(); // Impacts m_soundMap[SoundCue::BallLaunch] = LoadSound("SoundsImpactsBallLaunch.wav"); m_soundMap[SoundCue::Buzz] = LoadSound("SoundsImpactsBuzz.wav"); m_soundMap[SoundCue::Impact1] = LoadSound("SoundsImpactsImpact1.wav"); m_soundMap[SoundCue::Impact2] = LoadSound("SoundsImpactsImpact2.wav");...}SoundEffect^ AudioEngine::LoadSound(String^ filename){ Array^ soundData = m_mediaReader->LoadMedia(filename); auto soundEffect = ref new SoundEffect(); soundEffect->Initialize(m_audio->SoundEffectEngine(), m_mediaReader->GetOutputWaveFormatEx(), soundData); return soundEffect;}When the game needs to play a sound, it simply calls the PlaySound method, passing in the cue to play, and the volume to play it at. PlaySound keys into the sound map, getting the associated SoundEffect, and plays it.

void AudioEngine::PlaySound(SoundCue cue, float volume, bool loop){ m_soundMap[cue]->Play(volume, loop);}MJPEG Cameras

To achieve the effect of seeing the opponent in stereoscopic 3D, we strapped two Axis M1014 network cameras side-by-side. Using Brians MJPEG Decoder library, with a special port to Windows Runtime (available soon), individual JPEG frames were pulled off each camera, and then applied to a texture at the back of the arena. The image from the left camera is drawn when DirectX renders the players left eye, and the frame from the right camera is drawn when DirectX renders the right eye. This is a cheap and simple way to pull off live stereoscopic 3D.

void MjpegCamera::Update(GameEngine^ engine){ if(m_decoderLeft != nullptr) UpdateTexture(m_decoderLeft->CurrentFrame, &textureLeft); if(m_decoderRight != nullptr) UpdateTexture(m_decoderRight->CurrentFrame, &textureRight); Face::Update(engine);}void MjpegCamera::Render(_In_ ID3D11DeviceContext *context, _In_ ID3D11Buffer *primitiveConstantBuffer, _In_ bool isFirstPass, int eye){ if(eye == 1 && textureRight != nullptr) m_material->SetTexture(textureRight.Get()); else if(textureLeft != nullptr) m_material->SetTexture(textureLeft.Get()); GameObject::Render(context, primitiveConstantBuffer, isFirstPass);}With the distance between the cameras being about the distance of human eyes (called the intra-axial distance), the effect works pretty well!


The Tablet controller is the touch screen that lets the player control their 3D paddle in the Game Console app. For this part of the game system, there wasn't a reason to dive deep into DirectX and C++ since the controller is neither stereoscopic or visually intense, so we kept things simple with C#.
Since the controller would also serve as our attract screen in the podium to entice potential players, we wanted to have the wait screen do something eye-catching. However, if you are moving from C# in WPF to C# and XAML in WinRT and are used to taking advantage of some of the more common "memory hoggish UX hacks" from WPF, you'll quickly find them absent in WinRT! For example, we no longer have OpacityMask, non-rectangular clipping paths or the ability to render a UIElement to a Bitmap. Our bag of UX tricks may be in need of an overhaul. However, what we do get in C# / XAML for WinRT is Z rotation, which is something we've had in Silverlight but I personally have been begging for in WPF for a long time.
Therefore, the opening animation in the controller is a procedurally generated effect that rotates PNG "blades" in 3D space, creating a very compelling effect. Here is how it works. The Blade user control is a simple canvas that displays one of a few possible blade images. The Canvas has a RenderTransform to control the scale and rotation and a PlaneProjection which allows us to rotate the blade graphic in X, Y and Z space.

Each Blade is added dynamically to the Controller when the Tablet application first loads, stored in a List to have it's Update() method called during the CompositionTarget.Rendering() loop.

protected override void OnNavigatedTo(NavigationEventArgs e){ canvas_blades.Children.Clear(); _blades.Clear(); for (int i = 0; i < NumBlades; i++) { Blade b = new Blade { X = 950.0, Y = 530.0 }; int id = _rand.Next(0, 5); b.SetBlade(id); b.Speed = .1 + id * .1; SeedBlade(b); _blades.Add(b); canvas_blades.Children.Add(b); }}void CompositionTarget_Rendering(object sender, object e){ if(_inGame) { paddle.Update(); } else if(_isClosing) { foreach (Blade b in _blades) b.UpdateExit(); } else { foreach (Blade b in _blades) b.Update(); }}Since each Blade has been assigned an individual speed and angle of rotation along all three axis, they have a very straightforward Update function. The reason we keep the rotation values between -180 and 180 during the spinning loop is to make it easier to spin them out zero when we need them to eventually leave the screen.

public void Update(){ _rotX += Speed; _rotZ += Speed; _rotY += Speed; if (_rotX > 180) _rotX -= 360.0; if (_rotX < -180) _rotX += 360.0; if (_rotY > 180) _rotY -= 360.0; if (_rotY < -180) _rotY += 360.0; if (_rotZ > 180) _rotZ -= 360.0; if (_rotZ < -180) _rotZ += 360.0; projection.RotationX = _rotX; projection.RotationY = _rotY; projection.RotationZ = _rotZ;}public void UpdateExit(){ _rotX *= .98; _rotZ *= .98; _rotY += (90.0 - _rotY) * .1; projection.RotationX = _rotX; projection.RotationY = _rotY; projection.RotationZ = _rotZ;}Network

To continue the experiment of blending C# and C++ code, the network communication layer was written in C# as a Windows Runtime component. Two classes are key to the system: SocketClient and SocketListener. Player ones game console starts a SocketListener to listen for incoming connections from each game controller, as well as player twos game console. Each of those use a SocketClient object to make the connection.
In either case, once the connection is made, the client and the listener sit and wait for data to be transmitted. Data must be sent as an object which implements our IGamePacket interface. This contains two important methods: FromDataReaderAsync and WritePacket. These methods serialize and deserialze the byte data to/from an IGameState packet of whatever type is specified in the PacketType property.

namespace Coding4Fun.Maelstrom.Communication{ public enum PacketType { UserInputPacket = 0, GameStatePacket } public interface IGamePacket { PacketType Type { get; } IAsyncAction FromDataReaderAsync(DataReader reader); void WritePacket(DataWriter writer); }}The controllers write UserInputPackets to the game console, consisting of X,Y positions of the paddle, as well as whether the player has tapped the screen to begin.

public sealed class UserInputPacket : IGamePacket{ public PacketType Type { get { return PacketType.UserInputPacket; } } public UserInputCommand Command { get; set; } public Point3 Position { get; set; }}Player ones game console writes a GameStatePacket to player' twos game console, which consists of the positions of each paddle, each ball, the score, and which tiles are lit for the ball splitter power up. Player twos Update and Render methods use this data to draw the screen appropriately.

The hardware layer of this project is responsible for two big parts. One is a rumble effect that fires every time the player is hit, and the other is a lighting effect that changes depending on the game state.
As all good programmers do, we reused code from another project. We leveraged the proven web server from Project Detroit for our Netduino, but with a few changes. Here, we had static class modules which knew how to talk to the physical hardware, and controllers which handled items like a player scoring, game state animations, and taking damage. Because the modules are static classes, we can have them referenced in multiple classes without issue.
NETMF Web Server

When a request comes in, we perform the requested operation, and then return a new line character to verify we got the request. If you dont return any data, some clients will actually fire a second request which then can cause some odd behaviors. The flow is as follows:

Parse the URLGet the target controllerExecute the appropriate action

private static void WebServerRequestReceived(Request request){ var start = DateTime.Now; Logger.WriteLine("Start: " + request.Url + " at " + DateTime.Now); try { var data = UrlHelper.ParseUrl(request.Url); var targetController = GetController(data); if (targetController != null) { targetController.ExecuteAction(data); } } catch (Exception ex0) { Logger.WriteLine(ex0.ToString()); } request.SendResponse(NewLine); Logger.WriteLine("End: " + request.Url + " at " + DateTime.Now + " took: " + (DateTime.Now - start).Milliseconds);}public static IController GetController(UrlData data){ if (data.IsDamage) return Damage; if (data.IsScore) return Score; if (data.IsGameState) return GameState; // can assume invalid return null;}Making It Shake

We used a Sparkfun MP3 trigger board, a subwoofer amplifier, and bass rumble plates to create this effect. The MP3 board requires power, and two jumpers to cause the MP3 to play. It has an audio jack that then gets plugged into the amplifier which powers the rumble plates.
From here, we just needed to wire a ground to the MP3 players ground pin, and the target pin on the MP3 player to a digital IO pin on the Netduino. In the code, we declare it as an OutputPort and give it an initial state of true. When we get a request, we toggle the pin on a separate thread.

private static readonly OutputPort StopMusic = new OutputPort(Pins.GPIO_PIN_D0, true);private static readonly OutputPort Track1 = new OutputPort(Pins.GPIO_PIN_D1, true);// .. more pinspublic static void PlayTrack(int track){ switch (track) { case 1: TogglePin(Track1); break; // ... more cases default: // stop all, invalid choice TogglePin(StopMusic); break; }}public static void Stop(){ TogglePin(StopMusic);}private static void TogglePin(OutputPort port){ var t = new Thread(() => { port.Write(false); Thread.Sleep(50); port.Write(true); }); t.Start();}Lighting Up the Room

For lighting, we used some RGB Lighting strips. The strips can change a single color and use a PWM signal to do this. This is different than the lighting we used in Project Detroit which allowed us to individually control each LED and used SPI to communicate. We purchased an RGB amplifier to allow a PWM signal to power a 12 volt strip. We purchased ours from US LED Supply and the exact product was RGB Amplifier 4A/Ch for interfacing with a Micro-Controller (PWM/TTL Input).
We alter the Duty Cycle to shift the brightness of the LEDs and do this on a separate thread. Below is a stripped down version of the lighting hardware class.

public static class RgbStripLighting{ private static readonly PWM RedPwm = new PWM(Pins.GPIO_PIN_D5); private static readonly PWM GreenPwm = new PWM(Pins.GPIO_PIN_D6); private static readonly PWM BluePwm = new PWM(Pins.GPIO_PIN_D9); private const int ThreadSleep = 50; private const int MaxValue = 100; const int PulsePurpleIncrement = 2; const int PulsePurpleThreadSleep = 100; private static Thread _animationThread; private static bool _killThread; #region game state animations public static void PlayGameIdle() { AbortAnimationThread(); _animationThread = new Thread(PulsePurple); _animationThread.Start(); } #endregion private static void PulsePurple() { while (!_killThread) { for (var i = 0; i = 0; i -= PulsePurpleIncrement) { SetPwmRgb(i, 0, i); } Thread.Sleep(PulsePurpleThreadSleep); } } private static void AbortAnimationThread() { _killThread = true; try { if(_animationThread != null) _animationThread.Abort(); } catch (Exception ex0) { Debug.Print(ex0.ToString()); Debug.Print("Thread still alive: "); Debug.Print("Killed Thread"); } _killThread = false; } private static void SetPwmRgb(int red, int green, int blue) { // typically, 0 == off and 100 is on // things flipped however for the lighting so building this in. red = MaxValue - red; green = MaxValue - green; blue = MaxValue - blue; red = CheckBound(red, MaxValue); green = CheckBound(green, MaxValue); blue = CheckBound(blue, MaxValue); RedPwm.SetDutyCycle((uint) red); GreenPwm.SetDutyCycle((uint) green); BluePwm.SetDutyCycle((uint) blue); Thread.Sleep(ThreadSleep); } public static int CheckBound(int value, int max) { return CheckBound(value, 0, max); } public static int CheckBound(int value, int min, int max) { if (value = max) value = max; return value; }}Conclusion

We built this experience over the course of around 4 to 5 weeks. It was our first DirectX application in a very long time, and our first C++ application in a very long time. However, we were able to pick up the new platform and language changes fairly easily and create a simple, yet fun game in that time period.

Music track - "FatLoad- The Bullet(no master)" by FreaK NeoSSound effects + music edition - David WallimannDirectX shaders - Michael McLaughlin


My name is Grant and I am in charge of all the printer drivers and print
server functionality for a really big company. We have around 180,000
Windows users and I have heard we are actually the largest corporate Windows
network in the world.

I sent these suggestions (in 2 parts) to MS through
www.windowsserverfeedback.com. I got a response saying they liked some of
the ideas and have forwarded my sugesstions to some other people in MS. I am
posting this in case anyone else out there has some of these problems and
would like to comment on them or my solutions.

We have a couple hundred print servers and thousands upon thousands of print
queues. Needless to say, we have issues and problems that are not always
very common, but my ideas would benefit a lot of business users out there,
especially anyone using multiple print servers.

These are the primary print server issues we have:

#1 Migrating users to another print server with a different name
Every 2.5 years we lease roll our print servers. Sometimes we change the
name of the server, or move the queues to another server altogether.
Figuring out who the thousands of users that print to the old server are, and
migrating them to the new server continues to be a horrible exercise.

#2 Determining the users who print to each individual queue
It is unfortunately common to find a queue on the wrong server, such as
queue for a printer in Los Angeles on a Sacramento print server. Determining
the users who print just to that one specific queue is not fun. Migrating
them to an identical queue on a different server is less fun. It is so
difficult in fact, that we rarely ever do it.

#3 Determining if a queue is still used
The first thing I do before I migrate queues to a new server is I try my
best to determine which queues are no longer used. For print servers that
are 2-3 years old the average percentage of queues that have not been printed
to in the past 3 months is around 30-40%. It is startling to delete 150 out
of 350 queues because I find them not in use. Again, determining which
queues are not in use is not fun.

#4 Managing Printer Drivers
Standardizing which printer drivers are allowed on our print servers has
been a monster task. Enforcing our policy of ONLY using our approved drivers
has been impossible. Determining who installed a driver and/or where the
driver was loaded from, cannot be done and continues to give us the majority
of our driver problems.

#5 The System Event Log is a joke
The 10-20 daily system events are in the same log that creates an event for
every single print job, which is around 5000-6000 events per day per server.
Without increasing the size of the system event log this gives us only a few
days worth of events before they are overwritten.

Those are the main problems.
I have put a lot of time, thought and energy into my suggestions for fixing
these problems.

A. Printer Shortcuts
A printer shortcut would be exactly like a file shortcut (a file that when
executed directed the user to the location specified in the shortcut).
Printer Shortcuts would be in the Printers and Faxes folder, be shared, and
act just like printer queues. When the user printed to the printer shortcut
it would change the queue on the user’s PC to the queue the shortcut pointed
to. The printer shortcut could point to a queue on a different server or
even on the same server but with a different queuename.

Printer shortcuts would completely change how print queue migrations are
done. Queues would be created on the new server and the queues on the old
server would be replaced with printer shortcuts. Each time a user printed to
a queue on the old server it would migrate that user’s queue to the new
server, completely transparent to the user.

This would also allow administrators to migrate single queues to different
print servers that were closer to the physical printer or anywhere they
needed them to be.

B. Queue Migration Tool
Windows 2003 Print servers should have the ability to push or pull
individual, groups or all print queues and their drivers to and from other
2003 print servers. When a queue is moved a Printer Shortcut would be left
in its place.

C. Queue Logging
Each print queue should have the ability to track each print job title,
number of pages, user, time and date, size, and frequency of all the print
jobs printed to that queue.

Obviously this would take a considerable amount of resources compared to
what is tracked now (nothing) and it is not always necessary to track all or
some of this information. Each category should be selectable on a queue by
queue basis or on all queues. A date or time duration field would also be
needed, so you could set how far back you want to track. Ex: 1 month, 2
months, after Nov. 1st, etc.

Personally all we really NEED at SBC is the ability to track all the users
on specific queues, but the other data would be very useful.

This data needs to be stored in some kind of text or log file that can be
accessed as well. It should not be stored in the System Event Log

D. Queue Auto Management
Individually or as a whole queues should be configurable so if a queue (or a
Printer Shortcut) is not used for a set amount of time the queue is
automatically deleted or put into some kind of recycle bin. A log of this
kind of activity would need to be kept. If some kind of printer queue
recycle bin could be created the ability to restore deleted queues could be

E. Printer Driver Tracking
Every time a printer driver is installed on a server the user who installed
it and the location it was installed from needs to be logged. The specific
queue it was loaded for or if it was just loaded on the server in general
would also be useful information, but are not as critical as user and

F. Print Job Event Log
Print job events MUST be taken out of the System Event Log. A fourth Event
Log just for Print Jobs needs to be created. It would probably work well to
make the Queue Logging and Print Job Event Log work together.

As an administrator it is very important to get the System Event Log back.
Right now it is worthless.

G. Printer Driver Replication
It would be extremely useful to be able to replicate all of the printer
drivers on a Windows 2003 Server to other Windows 2003 Servers. As it stands
we have to load each individual driver on each individual server, thus the
versions of the drivers are always old or the wrong drivers are used. Only
during migrations of queues can we use Printmig to move drivers from one
machine to another, but that does not help with this problem.

H. Choose Which Driver From the Server Locally
This is a small fix but very important. During the creation of a print
queue, when choosing which driver to use the very first option should be a
drop down list box of drivers already loaded on the server. If the needed
driver is not already on the server then and only then should there be the
option to browse to the location of a printer driver to load.

As it stands, even if the needed driver is already loaded on the server the
person must go through a horrific process to specify that driver, and it
basically involves reloading the driver anyway. The current process is way
too complicated and confusing for our helpdesk people that create most of our

From what I can tell Print does not seem to be a priority for Microsoft.
There has been very little done to it since NT4 other than the introduction
of Version 3 drivers.

In this time of cost cutting I continue to fight off attacks by upper
management to consider moving our print server function to Linux. Right now
the transparent loading and updating of printer drivers by the server is the
only thing that winning the justification of Windows over Linux.

I know we are not the only large company that would greatly benefit from the
features I suggested. Using Linux for print servers is becoming all too
common. Windows Print needs attention desperately. I would love to discuss
this in more detail with someone involved with the print function of Windows


Currantly I have an Athlon 2100 running on an FIC board with a gig of
ram and a cheap 300 watt power supply. I do a lot of video editing and
have 4 internal 120 gig drives, two of which are configured in a raid
0 array using the MB's onboard Promise raid. I'm running WinXP Home.

Over the last month or so I've had problems with spontaneous
shutdowns and reboots. At first these occurances were infrequent
and actually stopped for about 3 weeks. But they are back and bad,
happening every few minutes on those few occasoions when the boot
sequence completes. Error messages are varied and range from blue
screens early in the boot process ( these are rare and include 8 E &
C2) , to the "windows has recovered from a serious error" message with
reference to minidump problems.

I know this could be software related, but I don't think so.I rewrote
the C Drive with an image file from 3 months before the problem
started. That should have eliminated a registry problem, virus, etc.,
but the problem continued. Norton A/V and Spybot S&D have found
nothing I think it's more likely hardware and could be heat, ram,
power supply, a short somewhere, or a failing component. I tried
running memtest from a boot floppy, but after working fine for two or
three minutes, the screen starts scrolling very rapidly in a diagonal
direction and can't be read. This scrolling had happened on reboots
for at least the past year, but wasn't a problem because it stopped as
soon as windows finished loading.

When I opened the case I found that there actually were components
buried in the dust and hidden under the tangle of cables. I'll clean
it first and try securing the cables out of the way. I have two sticks
of ram so next I'll pull one, then the other to see if one is bad.
But after that I may just go to Plan B.

I planned on adding a new pretty high-end computer to become my main
machine in 6 or 9 months. I can't afford to do that until then. I
planned on using my currant machine mainly for file storage and
back-up. Now I think I may upgrade my currant machine modestly to buy
time until I can afford my new machine, and at the same time get rid
of the reboot problem. I would get a new MB, a processor in the
3000-3200 range, ram, power supply, and mid-level video card. This
rebuilt machine would still be used mainly for file storage
eventually, but in the meantime it would be my main machine and allow
me to put off getting my high-end machine for a while longer.

If I do this, I worry about the files on the Raid 0 drives. While most
of them are backed up to an external drive, there are several of the
latest edits which didn't get backed up because of the crashes. I
would prefer to not lose them. If my new MB has onboard promise raid,
will I be able to read them ? What about an add-in raid card?

Any suggestions for fixing the reboot problem?

For Plan B:
Will it work if the problem is hardware?
What if it's software?
Will I need to do an XP Repair?
What about the Raid issue?
Any suggestions for components?

Dave W.

A recent news-handling problem has brought this one back, so I thought
I'd bring it up again.


I have a - non-networked - Windows 95 system, used for testing some
equipment. These tests create log files ON ITS HARD DISC (usually the
desktop, for convenience; they're only 41k files, in threes). As part of
our procedure, these log files have to be stored on our company network;
the procedure we use to do this is to copy them onto a floppy disc on
the '95 machine, carry it the few yards to the networked XP machine
which has a USB floppy drive, and copy the files to the network drive.
lost, so no recovery is necessary. The files are still there on the
desktop (hard drive) of the '95 system.

(Sorry for shouting, but throughout this thread, people have very kindly
spent a lot of time trying to help with recovery, which isn't needed.)

Purely out of perversity, I continue to use the floppy with the bad
sectors; I have other work I can do while waiting (or, if not, I use a
good floppy).

1. 95 machine. After experiencing problems, I rescan the floppy, on the
'95 machine, so that any newly-bad sectors get marked. (I'm curious as
to whether a scan rescans already-marked-as-bad sectors; I think it must
do, as it seems to take longer each time, whereas I wouldn't expect it
to if it was skipping already-marked-as-bad sectors.) While _doing_ this
scan, the '95 machine still lets me do other things, just incredibly
slowly, which puzzles me, though I accept what some people here have
said about low-level drivers and the like. (I don't have - nor the means
to install - any utilities, such as resource meters, that aren't part of
the basic '95 system.)

2. XP machine.
(a) When it is having problems reading the floppy, it goes through this
cycle many times: floppy drive light on and floppy turning; light off
and not turning _for several seconds_. (_What_ is it doing during that
time?) After many such cycles, it reports a problem. Until it does, it
becomes unresponsive in explorer windows, though I can do other things.
(b) If I try to close the explorer window with the X before it has given
up, it usually ignores me. If I close it with task manager, it does
close it, but is obviously upset: it blanks where the taskbar was
(eventually redrawing it), and does various other things which show it
isn't happy, including closing any other explorer windows (such as the
one showing the network drive I was copying the files to), _and these
are really closed and don't come back_, so it's not just an
incredibly-slow-redraw matter.
(c) After such, whether I wait (ages) for the error message or terminate
the process, it seems to have some "memory" that there was something
wrong: attempts to read even an OK floppy often don't work. I find
either closing the explorer window that was looking at drive A:, or
unplugging the USB floppy drive and putting it back (I usually use
another socket), make it read OK again.

(I report these as just curiosities that will probably now never be
solved - that project is coming to an end, so I won't have much
opportunity to investigate further - I think.)

(Read on ...)

In message , Twayne
In ,
J. P. Gilliver (John) typed:
On the XP system, if the read fails, it also seems to
lock up the system. I don't know _what_ it is doing: it
sits there, not even accessing the floppy continuously -
the light comes on for a few seconds, then goes off for a
few seconds, and eventually - sometimes after a minute or
more - comes up with an error message; again, the system
is a little sluggish to do anything else, though nothing
like as much so as the '95 system. But what is really
weird is that it seems to sulk where the floppy is
concerned: once it has decided there is a problem, it
refuses - by going into the
mode - to do _anything_ with the floppy, even delete or
rename a file, _or use a (different, good) floppy.
Sometimes, if I think it has locked up completely, I kill
the process with Task Manager, which works - XP is more
robust that way - but from the way it does it, it is
clearly having a _major_ effect: it usually closes _all_
explorer windows, blanks and eventually redraws the
taskbar, breaks iconoid, redraws the desktop, and so on.
Again, I can't see why doing something as trivial as
accessing a floppy - even if it's dud - should have such
a major effect on the system. (I also think the XP system
is less tolerant of the poor floppy.)
I repeat, I _know_ a good floppy is only pennies, and I
have one: it's just the principle that bugs me, of why
doing such a nominally simple thing should cripple both
systems so much.
(I've included the '98 newsgroup as I thought they might
be interested/have views/answers.)

Everyone who has responded so far has given good information. Taken
together, IMO they give a good picture of what's going on. A bit higher
level explanation might go thusly:

Being magnetic, floppy disks do lost their data over time as short as 6
[All good stuff but not an explanation of why the OSs are behaving as
they are.]
There are DOS programs around that are meant to "recover" decaying
floppies. Mine seems to be lost in the archives somewhere; all I see left is

And dud HDs - I forget the name, but we have one that will sit trying to
read a sector for ages; we left it for several days trying to salvage
something from a (I think it was all of 20M!) drive that had come with a
piece of equipment (from a division that was being closed down and
nobody knew where the backups were for this ancient equipment; I am sure
there would originally have been such).

the WordStar to Word converter, meaning several others are hiding away from
me too.
The "recover floppy" program did a lot better and more efficient job than
anything you could do manually and was often surpsingly effectively. I guess
Google would be the best way to find it now.

As I've explained, the data isn't lost (it's still on the machine it's
being copied from); I'm just curious as to why the OSs (if anything,
particularly the XP one; I accept a slowdown for the '95 one, at least
that's sort of understandable) are behaving as they do.

As for locking up the sy

(Not sure what happened there.)
J. P. Gilliver. UMRA: 1960/1985 MB++G.5AL-IS-P--Ch++(p)Ar@T0H+Sh0!:`)DNAf

# 10^-12 boos = 1 picoboo # 2*10^3 mockingbirds = 2 kilo mockingbird
# 10^21 piccolos = 1 gigolo # 10^12 microphones = 1 megaphone
# 10**9 questions = 1 gigawhat

Hi, I have two synchronised combos, whatever is sleected in A determines what can be selected in B. These two populate corresponding fields on a many form say field 1 and 2. I need a way of maintaining integrity when data is amended, for instance in box A number 1 will restrict box B to letters X or Y or Z, number 2 in box A will restrict to E or F or G. There is currently no enforcement to prevent a user who has perhaps entered a record of 1 and X then changing the combo box A to 2 and then being giving the options of E F or G in box 2, clicking in field 2 and have that updated with say G, the record then becomes 1 and G, i.e. incompatable as 1 and G don't go. What code could I use the force compatability.

Thanks Darren.

I have code that uses a range name made of discontiguous cells that errors if a user has deleted rows or columns containing part of the range, because the name reference becomes invalid, like this:

=Summary!$B$55:$B120,Summary!$B$59:$B$60,Summary!# REF!

The cells are always in the same location so I guess I can rebuild the name at the point when that code is run, but since the Range Names are preset in the template I'm wondering if there is another solution ...

I have some code which is designed to fill and show up to 3 comboboxes on a userform. The entries are derived directly from data on the "Categories" worksheet (attachment).

Combo1 contains the unique values in column A. When the user selects a value in Combo1, the code iterates the spreadsheet rows with the appropriate values in column A, and if there are non-null column B values, they are added to Combo2 and the control becomes visible.

The same method is repeated to derive Combo3 entries from the Combo2 selection, and show the control if there are any entries. The test for a non-empty combobox is:

If ComboBox2.ListCount > 0 Then ComboBox2.Visible = True

This works for ComboBox2, but not ComboBox3. I have established that it fails when there are non-empty cells in column B, above the range of current interest. For instance, referring to the attached sheet, the method will fail for:

Office Stationery -> Desktop & Personal

because the row above this contains the value "Ruled" in column C:

Office Stationery -> Books -> Ruled

The behaviour is consistent for such cases, and Combo3 will end up containing a single null entry and has a ListCount of 1 - it should be zero.

I can fudge a fix for the specific data I have by making the condition:

If ComboBox3.ListCount > 1 Then ComboBox3.Visible = True

but this is, of course, not generally satisfactory.

I'm hoping that somebody can see what's happening here, and what the fix is of course . I've been brickwalling with this for hours, and I'm out of ammo I'm afraid.



Page 1 of 2.
Results 1...20 of 40