Slashdot Mirror

Windows 8 comes with app store functionality bundled.

Applications available through this store must use only the Windows Runtime API (section 3.1). This API lacks DirectInput (source), which means Windows Store games on desktop computers can't use inexpensive or specialized game controllers. They're limited to a keyboard (for Player 1 only), a mouse (for Player 1 only), and an Xbox 360 Controller (which must be licensed by Microsoft). Games must be fully playable with a touch screen alone (section 3.5), which rules out several genres that rely on giving the player physical buttons to perform actions, and it can't have more than five seconds of loading even when run on the cheapest Atom-powered computer with a spinning disk hard drive (section 3.8). Nor may it allow users to create scripts and share them with one another (section 3.9), ruling out user-created game mods that aren't just mesh/texture swaps and the entire Programming Game genre. Nor do games with retro-style low-definition pixel-art graphics like Mega Man 9 appear to be supported, as their screenshots are smaller than 1366x768 (section 6.8).

Windows 8 comes with app store functionality bundled.

Applications available through this store must use only the Windows Runtime API (section 3.1). This API lacks DirectInput (source), which means Windows Store games on desktop computers can't use inexpensive or specialized game controllers. They're limited to a keyboard (for Player 1 only), a mouse (for Player 1 only), and an Xbox 360 Controller (which must be licensed by Microsoft). Games must be fully playable with a touch screen alone (section 3.5), which rules out several genres that rely on giving the player physical buttons to perform actions, and it can't have more than five seconds of loading even when run on the cheapest Atom-powered computer with a spinning disk hard drive (section 3.8). Nor may it allow users to create scripts and share them with one another (section 3.9), ruling out user-created game mods that aren't just mesh/texture swaps and the entire Programming Game genre. Nor do games with retro-style low-definition pixel-art graphics like Mega Man 9 appear to be supported, as their screenshots are smaller than 1366x768 (section 6.8).

Windows 8 comes with app store functionality bundled.

Applications available through this store must use only the Windows Runtime API (section 3.1). This API lacks DirectInput (source), which means Windows Store games on desktop computers can't use inexpensive or specialized game controllers. They're limited to a keyboard (for Player 1 only), a mouse (for Player 1 only), and an Xbox 360 Controller (which must be licensed by Microsoft). Games must be fully playable with a touch screen alone (section 3.5), which rules out several genres that rely on giving the player physical buttons to perform actions, and it can't have more than five seconds of loading even when run on the cheapest Atom-powered computer with a spinning disk hard drive (section 3.8). Nor may it allow users to create scripts and share them with one another (section 3.9), ruling out user-created game mods that aren't just mesh/texture swaps and the entire Programming Game genre. Nor do games with retro-style low-definition pixel-art graphics like Mega Man 9 appear to be supported, as their screenshots are smaller than 1366x768 (section 6.8).

So what does DirectX 11.1 and .2 do that's so important that people will abandon Windows 7?

Per New or updated in Windows 8.1 Preview:

HLSL shader linking
Inbox HLSL compiler
GPU overlay support
DirectX tiled resources
Direct3D low-latency presentation API
DXGI Trim API and map default buffer
Frame buffer scaling
Multithreading with SurfaceImageSource
Interactive Microsoft DirectX composition of XAML visual elements
Direct2D batching with SurfaceImageSource

IMHO the big one is probably tiled resources. Think minecraft world virtually on the graphics card. From the applications perspective that it how it controls the graphics card. The app then also provides services for the graphics engine to request tiles with given scale at demand.

call Microsoft Activation and advise you have downgraded to Windows 7 as allowed as part of the OEM licensing agreement and would like their assistance in activating.

Have you read the OEM licensing agreement?

You can only 'downgrade' if you purchase Windows 8 Pro, which is, a) Not always an option on consumer machines, b) Much more expensive.

Ref: http://www.microsoft.com/OEM/en/licensing/sblicensing/Pages/downgrade_rights.aspx

From the Microsoft Volume Licensing Brief - Downgrade Rights PDF available here:

Rights to OEM versions of system software are granted in the OEM License Terms. The OEM License Terms for Windows 8 Pro, Windows 7 Professional, Windows 7 Ultimate, Windows Vista Business, and Windows Vista Ultimate operating systems grant downgrade rights. See the full text of the OEM License Terms for the specific downgrade rights

So please tell me why you need to purchase anything? If you buy a PC with Windows 8 then install Windows 7 and call Microsoft Activation and advise you have downgraded to Windows 7 as allowed as part of the OEM licensing agreement and would like their assistance in activating.

takes 5 minutes to boot...

My Win 7-64 with 16GB RAM takes about 20 seconds excluding BIOS, you could try updating drivers / using something like bootvis ( http://msdn.microsoft.com/en-us/performance/default.aspx )

They shouldn't work with a full DRM stack including video drivers. See http://msdn.microsoft.com/en-us/library/windows/desktop/aa376846(v=vs.85).aspx

Microsoft doesn't owe a new version of Internet explorer to users of windows XP. Considering that the upgrade to the latest version of windows was available for $40 for a long time,

Skipping your hate. Microsoft owes Internet explorer to users of windows because they paid for it, an now due to it being irremovable by monopolistic bundling, and you lie about the upgrade...In costs $199 for the less crippled *udgrade* edition http://windows.microsoft.com/en-us/windows/buy more if you live elsewhere.

The problem with supporting PlayReady is that Microsoft does not
currently license PlayReady for desktop use, they only license it for
embedded systems use.

Embedded systems are perceived as being more secure and as being
harder for an attacker to break the DRM. I remain skeptic about this
point, but those are the rules under which they allow PlayReady to be
licensed and we are not in a position to license it for the desktop.

We are aware of some vendors using Linux + Moonlight on embedded
systems that are engaging Microsoft to license PlayReady DRM and will make those combinations work out of the box on an embedded system.

It might be possible that all Embedded netflix implementations use this "Play Ready" licensed stack. I don't think so, but it's a possibility. So now that Netflix has their own DRM stack, there is a new light for official Netflix on linux (if they care enough for my money).

The correct one:

http://msdn.microsoft.com/en-us/library/windows/desktop/aa384649(v=vs.85).aspx

For a list of in-box (Windows' own internal VSS writers that ensure disk consistency) see here: http://msdn.microsoft.com/en-us/library/windows/desktop/bb968827(v=vs.85).aspx

Oracle is an external VSS writer. Has supported VSS for many years.

The correct one:

http://msdn.microsoft.com/en-us/library/windows/desktop/aa384649(v=vs.85).aspx

For a list of in-box (Windows' own internal VSS writers that ensure disk consistency) see here: http://msdn.microsoft.com/en-us/library/windows/desktop/bb968827(v=vs.85).aspx

Oracle is an external VSS writer. Has supported VSS for many years.

mysqldump? But what you are doing, i.e backup of the database files directly, is a very dangerous form of backup. Restoring such when the database has been corrupted for whatever reason

Actually no, it is not dangerous provided that you use a backup agent or an operating system that supports this. Windows does, Linux and Unix do not.

On Windows the Volume Shadow Copy Service (VSS) will interact with registered processes to coordinate *when* they should ensure persistent consistency - which is reserved as a fraction of a second. It requires the processes to register as VSS writers - which database servers generally do (Oracle and SQL Server do - I do not know if MySQL does).

On Windows in a virtual environment this will even propagate through VM volumes, i.e. if you backup the host of the VMs (where some of the VMs could be running database servers), the host VSS service will ask the guest VSS service to ensure consistency right when the disk image file is being backed up. This means that you can backup the host Hyper-V server with all the disk images and rest assured that the VMs are consistent.

Huge boon for uptime.

tries to tell people like me that GIMP is just as good as PhotoShop, LibreOffice is just as good as MS Office

Sorry sweetness not sure of relevance Gimp is better than Photoshop http://www.adobe.com/products/catalog/software._sl_id-contentfilter_sl_catalog_sl_software_sl_photoshopcc.html which now costs $20 a month for its creative cloud version, Gimp is free...for me Gimp is a no brainer. I began using it as a consultant because I could install it on companies Desktop machines without License issues 15 years ago. I now run it from a pen drive.

LibreOffice is better than Office because the version I think I want is http://office.microsoft.com/en-us/business/office-365-small-business-premium-office-online-FX103037625.aspx which costs me $12.50 a month Its a little cheaper if I didn't need access.

What is frightening is both these companies(Adobe and Microsoft) are pushing me towards cloud(sic) versions of their products. Personally I these have no advantages but have a $32.50 Disadvantage...and have to use a always on-online DRM version.(ironically both should work on android in future or be avoided if they don't). think I'm the only one...Office launched on ios with a $100 a year fee for crippled version...nobody cared. its like its not happened.

This argument is nothing to do with Metro...which is shift in the Desktop interface to tablet one by Microsoft, in an poor attempt to convert its Desktop Monopoly into a Mobile one (say it with me ecosystem..cringe), and its a massive failure...they are installing it alongside Android now see what the article is about. This is nothing to do with comparing open source programs with Adobe and Microsoft equivalent those who have learnt to use them experience massive cost savings and smugness, although thanks for the Nostalgia.

http://www.prweb.com/releases/2013/6/prweb10796698.htm Estimates that the Games Industry is worth....$66Billion Revenue, but only $20Billion of that was from the PC gaming...Microsoft earned that in just one quarter http://www.microsoft.com/Investor/EarningsAndFinancials/Earnings/FinancialStatements/FY13/Q3/IncomeStatements.aspx. If you want to know why computers cost so much compared to tablets...$16Billion of that $20Billion was Gross profits...Bill Gates the humanitarian says they shouldn't pay tax on it though.

Luckily Windows 7 EOL isn't until 2015.

Windows 7 extended support (i.e. security patches) continues until Jan. 14, 2020. (source)

Too bad it wasn't in Windows 8.0

<pedanticdickweed>

How do you know? Are you from the future?

"Windows 8" is just a marketing name for Windows (NT) 6.2. "Windows 8.1" is a marketing name for "Windows 8" SP1, which is likely to share the 6.2 version number. Since 4.0 came out in 1996, and 6.0 (Vista) came out in 2007, that means it can take 11 years to go two full version releases. A simple extrapolation would estimate Windows 8.0 to be released around 2018. A more thorough analysis would note that the length of time between the releases of 4.0 and 5.0 is less than that between the releases of 6.0 and 6.2, thus it will likely take much longer to reach 8.0.

</pedanticdickweed>

Can anybody find anything useful on how exactly this 'driver model' works? Microsoft's page could hardly be less informative.

What's the intermediate format that software interacts with to define the print job before sending it off? What interface does the device-specific driver interact with, etc, etc?

Obviously, not having 3d printers be handled entirely by a specific application is a noble goal; but there are, even after years and years of polishing and development, some truly horrible things living in the 2d printing process. What can we expect from the details of the 3d-print path?

If you have Microsoft skills, Microsoft does not require degrees for coders in Redmond or for field reps (Windows server, active directory, exchange, sql server, sharepoint, etc) around the world. Management actively fights discrimination including age discrimination. The focus is on how well a person can do the job. http://careers.microsoft.com/

It was the way things were done in win9x. Moving to Win2k was a slap in the face when this was no longer supported

http://support.microsoft.com/kb/182708

"The video adapters that are installed in your computer do not have to be identical. Each video adapter and monitor combination is separately enumerated by Windows; you can configure each combination to use different screen resolutions and color depths. For example, you can set the primary adapter to 1024 X 768 pixels with 256 colors and the secondary adapter to 800 X 600 pixels with 32,000 colors. "

You are talking about Mac OS X. Windows is not that smart.

No, I was talking about Windows (Vista and above). And yes, it is that smart.

At the same time, most apps that don't declare themselves as high-DPI aware really aren't (in fact, some which do also aren't). The good old Win32 UI APIs mostly measure things in device-dependent pixels (except for CreateDialog, which uses device-independent "dialog units"). The first UI framework that was DPI-independent through and through was WPF, and that came in relatively late, in 2006. On the other hand, with WPF, it is practically impossible to write an app that is not DPI-aware (because even WPF pixels are logical).

Some of those AV companies are Chinese.

Care to list out the name of the AV companies which are owned and/or operated by the CHINESE ??

I am interested in factual information, not fear mongering !!

The MAPP program is public. You can find the list of MAPP partners at Microsoft Security Response Center

Huawei is there, as well as several Beijing companies.

My emphasis on Chinese was tongue-in-cheek. They get a few days advantage to develop scanning signatures. Yes, some of them may go rogue or (more likely) some of the employees. I would think that is why they only get a few days head start and not several months.

Rising are a Chinese company listed as an anti-virus partner by Microsoft.

Now, could they theoretically track your traffic back to its origin if they have a complete picture of the network? It's possible, but they can only do a positive ID when there's not much TOR traffic, especially near your physical location, to begin with. That's where security by obscurity comes into play.

Tor's anonymity can be broken with traffic analysis (i.e., of packet timing and sizes) by an adversary that can see both endpoints (i.e., the traffic between the user and first node, and the traffic between the exit node and destination) [1] [2]. There's a lot more work on this topic.

Whether or not there's "much Tor traffic" around you has little to do with it. The only requirement is that YOU send enough packets via Tor for it to be possible to correlate the traffic at both endpoints. The amount of traffic needed for that may be a function of the Tor traffic around you, but it's still very possible to de-anonymize a Tor user who sends a realistic amount of data over Tor.

It's also not necessary for the adversary to have a complete picture of the network. It's only necessary for the adversary to see that traffic at both endpoints. I suspect this is disturbingly easy for the NSA given their ability to monitor traffic at US tier-1 provider(s).

This is currently the single most important problem Tor has. There's been much research into avoiding it, but no one has come up with a good solution. The difficulty is that there's a trade-off between latency and the power of traffic analysis. If only a small amount of latency is artificially introduced, traffic analysis is still feasible. Mix networks are not susceptible to traffic analysis because they introduce a large amount of latency and are thus useless for interactive applications.

http://social.technet.microsoft.com/Forums/office/en-US/6fad3461-49cb-4f53-913b-7b8dbfaa8c75/office-2013-crashing-after-printing-to-hp-laser-printers

There you go.

You may be interested in this article. We have had mixed success with it.

Some were, some weren't. E.g., how did delegates make it easier to "write code that only ran on Windows"?

Async is (or was) a pretty standard feature in some languages and run time systems and operating systems. Usually it's just a library or operating system you can use, but ya, that's not integrated into the language itself. But consider Ada with asynchronous transfer of control. Erlang has asynchronous stuff, but maybe that looks too much like message passing. Certainly Smalltalk allowed you to have blocks executed asynchronously. Though it all depends upon what your definitions are, it's too easy to say that it's just boring old message passing and it's not really in the language unless there's some special syntax for it.

Async in the context of C# usually refers to async/await. If you're familiar with PL concepts, the concise way to describe it is that it takes a sequential algorithm, and rewrites it in continuation-passing style for you, with continuation boundaries explicitly determined by where you put 'await" in your code. E.g. consider this:

s = file.ReadLine();
Console.WriteLine(s);
s = file.ReadLine();
Console.WriteLine(s);

This code is just reading two lines synchronously, blocking the thread between two reads waiting on I/O to complete. If you wanted to avoid blocking the thread, you can write that with a chain of callbacks, much like what you see in Node.js etc:

file.ReadLineAsync().ContinueWith(t1 =>
  Console.WriteLine(t1.Result)
).ContinueWith(t2 =>
  Console.WriteLine(t2.Result)
);

This works, but it gets tedious when you have long chains, and even more tedious when you have nested chains. Worse yet, rewriting loops in this manner is not trivial. For example, simple synchronous code like this:

while ((s = file.ReadLine()) != null) {
  Console.WriteLine(s);
}

becomes this mess if redone async callback style:

Action<Task<string>> body = t => {
  string s = t.Result;
  if (s != null) {
    Console.WriteLine(t.Result);
    file.ReadLineAsync().ContinueWith(body);
  }
};
file.ReadLineAsync().ContinueWith(body);

On the other hand, with async/await, the first example becomes:

s = await file.ReadLineAsync();
Console.WriteLine(s);
s = await file.ReadLineAsync();
Console.WriteLine(s);

and the second one is:

while ((s = await file.ReadLineAsync()) != null) {
  Console.WriteLine(s);
}

Note how the only difference between async and sync code here is the addition of "await", and the use of ReadLineAsync instead of ReadLine. Compiler transforms all that to code with callbacks, automatically inserting one in every place where "await" is used (and rewriting loops etc as needed).

Really, all of this is just coroutines married to futures. In some other languages, you can take existing coroutine support and implement futures as a library (e.g. in Python, where "yield" becomes the equivalent of "await").

Not really sure what LINQ is exactly, but it sounds a bit like SQL embedded within a language. Couldn't you do the same thing with a library call? What about Perl being able to query and filter data that it has?

LINQ is a lot of different things that combine together. Let me try to go point by point.

The first piece is what other languages call list or sequence comprehensions. If you ever wrote something like:

[x*2 for x in range(10) if x % 2 == 0]

in Python, you've used that. LINQ uses a less concise syntax that is more reminiscent to SQL for the same thing - e.g. the example above would be:

from x in Enumerable.Range(0, 10) where x % 2 == 0 select x*2

in C#, but semantics are the same. That syntax is actually just syntactic sugar for a bunch of method calls with lambdas, with keywords mapped to methods with the same name - the expression above, for example, is translated to:

Enumerable.Range(0, 10).Where(x => x % 2 == 0).Select(x => x*2)

And Where and Select can be pretty much anything - e.g. the return type of Where doesn't matter, so long as it has a method called Select on it. Standard collection types provide implementations that do what you'd expect them to do (not directly, but rather via a mechanism called "extension methods", which allows you to add members to existing types - but this doesn't really matter to the developer using this API).

The second part are lambdas themselves. When you see x => x % 2 == 0, this has pretty much the same meaning as arrow-based lambda syntax in other languages using it (like Scala), with type of x inferred from the context in which it is used. However, there's a twist: instead of compiling this to a function and passing a reference to that, there's also an option of implicitly "quoting" lambda expressions as ASTs. Simply put, if the function you are passing the lambda to as a parameter declares the type of that parameter as Expression, then that function gets the AST for the lambda body, instead of compiled code.

This allows the function to interpret that AST in different ways at runtime instead of just compiling and running it (though that remains an option). For example, in LINQ to SQL and Entity Framework, the AST is converted to SQL, and passed on to the server. In general, the idea is that you have various LINQ providers (i.e. implementations of Where, Select etc) accepting ASTs and converting them to whatever query language is used by the backend that you're extracting the data from. Thus, you have a single uniform syntax for queries, that is also strongly typed (can also be weakly typed since "dynamic" was introduced in C# 4.0), but which can be handled in different ways depending on what data you're querying.

Then Microsoft asked "wouldn't this be better if it didn't suck?" So they worked on it. They "improved" on it. Thus was born the Windows-only J++ language. It was Java, only with extra stuff to make it work more Windows-y. Around the same time, Microsoft started considering the possibility of making the JRE also not suck. To that end, they hired Anders Hejlsberg and let him loose in the managed runtime labs to play with (torture?) JRE and VBRUN (oh, yes, we all remember VBRUN##).

J++ did indeed have additional language features, but they were not particularly "Windows-y". The only prominent thing that I can remember was the addition of delegates (basically, nominal function types) to the language.

What made J++ "Windows-y" was all the various extensions to the Java standard library that it had - in particular, Windows Foundation Classes. This was a UI library that wrapped native OS widgets (unlike Swing), but which wasn't platform-independent (unlike AWT) - it was very clearly and specifically about Win32. All in all, it looked a lot like someone took Delphi's VCL (which back then was by far the most popular RAD UI framework on Windows), and ported it to Java. It was also very similar to how VB did UI, although more powerful. As a result, you could write apps in it that didn't look and feel slow or alien to the platform, and a lot of people already had VB or Delphi skills that they could start using with J++. Swing, in contrast, had a much steeper learning curve, and visually apps using it were an eyesore to the users, not to mention all the UI lag.

The story with MS JVM is a bit different. Basically, when it came out, Sun was still struggling with performance of their own VM (they caught up with HotSpot maturing later on, and now they're actually faster than .NET in many cases, but it was too late by then on the desktop), and it turned out that MS JVM was considerably faster back then - and because of that, most people who ran Windows (i.e. most everyone on the desktop) used it to run Java stuff. Which, in turn, meant that developers were more likely to pick up and use MS-specific features (like delegates or WFC), knowing that, standard or not, most of their userbase have them already. That's what got Sun all riled up - they were facing a very real possibility of Java being hijacked from them altogether. Officially, they specifically sued because both MS JVM and J++ were advertised as "Java", and that's a Sun trademark, the license to use which comes with a lot of strings attached - including a requirement to conform to various specs and to not extend the language and the library willy-nilly.

When Sun sued and won, J++ was officially scrapped, but in practice a lot of that work was revived under .NET umbrella. If you compare Windows Forms and WCF APIs, for example, there are a lot of similarities there. Delegates because a prominent language feature in C#, practically as-is. And, of course, C# 1.0 itself was a lot like Java cross-bred with Delphi (properties, explicit virtual etc).

Fast forward a few years. Java is at 1.4, and everyone wants generics. That same year, .Net 2.0 has generics. Java caught up within a few months

Your ordering is wrong here. Java got generics in 1.5 (aka 5.0), which was released in 2004. .NET (and C# & VB) got generics in 2.0, which was released in 2005. So Java was actually first to the market here, but their implementation of generics was inferior in many ways, and especially in performance (unboxing primitives every time you iterate over a collection is insanely expensive).

What .NET 2.0 added that Java didn't have, and still doesn't have, is anonymous delegates - which is just a fancy way to say "function literals and c

Then Microsoft asked "wouldn't this be better if it didn't suck?" So they worked on it. They "improved" on it. Thus was born the Windows-only J++ language. It was Java, only with extra stuff to make it work more Windows-y. Around the same time, Microsoft started considering the possibility of making the JRE also not suck. To that end, they hired Anders Hejlsberg and let him loose in the managed runtime labs to play with (torture?) JRE and VBRUN (oh, yes, we all remember VBRUN##).

J++ did indeed have additional language features, but they were not particularly "Windows-y". The only prominent thing that I can remember was the addition of delegates (basically, nominal function types) to the language.

What made J++ "Windows-y" was all the various extensions to the Java standard library that it had - in particular, Windows Foundation Classes. This was a UI library that wrapped native OS widgets (unlike Swing), but which wasn't platform-independent (unlike AWT) - it was very clearly and specifically about Win32. All in all, it looked a lot like someone took Delphi's VCL (which back then was by far the most popular RAD UI framework on Windows), and ported it to Java. It was also very similar to how VB did UI, although more powerful. As a result, you could write apps in it that didn't look and feel slow or alien to the platform, and a lot of people already had VB or Delphi skills that they could start using with J++. Swing, in contrast, had a much steeper learning curve, and visually apps using it were an eyesore to the users, not to mention all the UI lag.

The story with MS JVM is a bit different. Basically, when it came out, Sun was still struggling with performance of their own VM (they caught up with HotSpot maturing later on, and now they're actually faster than .NET in many cases, but it was too late by then on the desktop), and it turned out that MS JVM was considerably faster back then - and because of that, most people who ran Windows (i.e. most everyone on the desktop) used it to run Java stuff. Which, in turn, meant that developers were more likely to pick up and use MS-specific features (like delegates or WFC), knowing that, standard or not, most of their userbase have them already. That's what got Sun all riled up - they were facing a very real possibility of Java being hijacked from them altogether. Officially, they specifically sued because both MS JVM and J++ were advertised as "Java", and that's a Sun trademark, the license to use which comes with a lot of strings attached - including a requirement to conform to various specs and to not extend the language and the library willy-nilly.

When Sun sued and won, J++ was officially scrapped, but in practice a lot of that work was revived under .NET umbrella. If you compare Windows Forms and WCF APIs, for example, there are a lot of similarities there. Delegates because a prominent language feature in C#, practically as-is. And, of course, C# 1.0 itself was a lot like Java cross-bred with Delphi (properties, explicit virtual etc).

Fast forward a few years. Java is at 1.4, and everyone wants generics. That same year, .Net 2.0 has generics. Java caught up within a few months

Your ordering is wrong here. Java got generics in 1.5 (aka 5.0), which was released in 2004. .NET (and C# & VB) got generics in 2.0, which was released in 2005. So Java was actually first to the market here, but their implementation of generics was inferior in many ways, and especially in performance (unboxing primitives every time you iterate over a collection is insanely expensive).

What .NET 2.0 added that Java didn't have, and still doesn't have, is anonymous delegates - which is just a fancy way to say "function literals and c

So, you're saying that idiots that couldn't code ASP can't code PHP. Color me suprised then.

ASP (or better ADO) has provided prepared statements for a long time. Not using them is not ASP's fault.

Create a stored procedure and swap

cmdPrep1.CommandText = "UPDATE titles SET type=? WHERE title_id =?"
cmdPrep1.CommandType = adCmdText

in that snippet for

cmdPrep1.CommandText = "name of stored procedure here"
cmdPrep1.CommandType = adStoredProc

and you're even better.

If you look at the lambda examples from Java 8 it looks like the collections API now mimic LINQ.

But still no expression trees and no ad-hoc anonymous types so nothing resembling LINQ to Entities, LINQ to Twitter etc.

Dynamic support in Java is called Invoke Dynamic and available in Java 7.

The dynamic support in Java is in the VM only. You cannot use foreign language objects as first class objects from within Java. Essentially, Javas dynamic support was created to make dynamic languages on the Java VM platform not suck. It is not a Java language feature.

C#s dynamic feature is support for dynamic languages the same way, but also lets you create objects in a foreign language and pass those to C# where they can be used as first-class objects.

Take a look here

As for async; Java has the concurrency package to make up for that.

Javas concurrency package is roughly on par with .NETs System.Threading.Tasks and System.Collections.Concurrent. .NETs tasks are more elegant due to the ability to use lambdas

Async/await goes beyond that and introduces syntactical notation where you can write asynchronous code and let the code resemble the logical flow even though dynamically the code executes asynchronously, i.e. the thread leaves and execution continues later when the event that is being awaited occurs.

There's the good kind of restraint and there's the poor kind of restraint, for example just recently I heard that datetime2 had been banned on our SQL Server because it had "useless higher precision we don't need and takes more space". Except datetime is 8 bytes, datetime2 would be 6 bytes with the 0 fractional second precision we need and 8 bytes at the worst. Not that I think it's really what's bogging us down despite having 100M+ row tables, in my book 100M * 2 bytes = 200MB which is a fart compared to the data amounts we're processing. He's the old kind of gray hair who's working to give me gray hair, I now avoid his advice when I can so I don't have to go against it.

We're not doing Unicode (varchar over nvarchar) for similar reasons, and there's opposition to indexes and foreign keys that slow things down. That's great if you want a write-only database with no integrity checks, but table scans makes it almost useless to query. And yes I've had to fight for more memory on my development workstation because I'm testing a process that takes ~10GB of RAM to run on the production server (which has 120 and is the only place this code is going to run) but pretty much chokes on my 8GB. I lost that fight, so I can run smaller files but if one of the huge ones dies in production, well good luck debugging that. ACing since I'm bad mouthing both my employer and semi-boss (not formally and HR-wise, but who manages me in practice).

There's the good kind of restraint and there's the poor kind of restraint, for example just recently I heard that datetime2 had been banned on our SQL Server because it had "useless higher precision we don't need and takes more space". Except datetime is 8 bytes, datetime2 would be 6 bytes with the 0 fractional second precision we need and 8 bytes at the worst. Not that I think it's really what's bogging us down despite having 100M+ row tables, in my book 100M * 2 bytes = 200MB which is a fart compared to the data amounts we're processing. He's the old kind of gray hair who's working to give me gray hair, I now avoid his advice when I can so I don't have to go against it.

We're not doing Unicode (varchar over nvarchar) for similar reasons, and there's opposition to indexes and foreign keys that slow things down. That's great if you want a write-only database with no integrity checks, but table scans makes it almost useless to query. And yes I've had to fight for more memory on my development workstation because I'm testing a process that takes ~10GB of RAM to run on the production server (which has 120 and is the only place this code is going to run) but pretty much chokes on my 8GB. I lost that fight, so I can run smaller files but if one of the huge ones dies in production, well good luck debugging that. ACing since I'm bad mouthing both my employer and semi-boss (not formally and HR-wise, but who manages me in practice).

will pay researchers $100,000 for a new exploit technique that is capable of bypassing the latest existing mitigations in the newest version of Windows."

In this style: http://technet.microsoft.com/en-us/security/bulletin/ms12-020

Bug no.: 54321
Severity: Critical
FAQ: Allows privilege escalation
Mitigating factors:

1. There are only 3 genuine users of the latest version of our operating system

2. We care a damn about affected earlier versions since those lousy bastards need to upgrade anyway

So it is a bug yes, latest version affected yes, but Bounty for you? No!!

Async:
http://msdn.microsoft.com/en-us/library/vstudio/hh191443.aspx
Syntax for composing continuations of asynchronous-capable tasks as if it is synchronous code. Whether or not it is truly asynchronous depends on the implementation of the called method and how quickly each task completes. The context under which the continuation executes is ambient allowing desktop applications to continue on the user-interface thread and for web applications to continue under any thread attached to the current HTTP request.

public async Task InsertWebContentIntoDb(string url)
{
        string content = await WebClient.DownloadStringAsync(url);
        try
        {
                int newId = await InsertIntoDatabase(content);
                return newId;
        }
        catch (Exception exception)
        {
                await LogException(exception);
                return -1;
        }
}

Generators/Iterators:
http://msdn.microsoft.com/en-us/library/vstudio/dscyy5s0.aspx
Functions which can generate/iterator any number of values and enumerated. Can contain almost any imperative code (some limitations on try/catch constructs) and return infinite values. Implemented via a state machine the portions of code only execute when the enumerator moves to the next value of the iterator.

The following only prints Bob and never prints END.

public IEnumerable GetNames()
{
        yield return "Bob";
        yield return "James";
        yield return "Samantha";
        Console.WriteLine("END!");
}

public void EnumerateNames()
{
        foreach(string name in GetNames())
        {
                Console.WriteLine(name);
                break;
        }
}

Async:
http://msdn.microsoft.com/en-us/library/vstudio/hh191443.aspx
Syntax for composing continuations of asynchronous-capable tasks as if it is synchronous code. Whether or not it is truly asynchronous depends on the implementation of the called method and how quickly each task completes. The context under which the continuation executes is ambient allowing desktop applications to continue on the user-interface thread and for web applications to continue under any thread attached to the current HTTP request.

public async Task InsertWebContentIntoDb(string url)
{
        string content = await WebClient.DownloadStringAsync(url);
        try
        {
                int newId = await InsertIntoDatabase(content);
                return newId;
        }
        catch (Exception exception)
        {
                await LogException(exception);
                return -1;
        }
}

Generators/Iterators:
http://msdn.microsoft.com/en-us/library/vstudio/dscyy5s0.aspx
Functions which can generate/iterator any number of values and enumerated. Can contain almost any imperative code (some limitations on try/catch constructs) and return infinite values. Implemented via a state machine the portions of code only execute when the enumerator moves to the next value of the iterator.

The following only prints Bob and never prints END.

public IEnumerable GetNames()
{
        yield return "Bob";
        yield return "James";
        yield return "Samantha";
        Console.WriteLine("END!");
}

public void EnumerateNames()
{
        foreach(string name in GetNames())
        {
                Console.WriteLine(name);
                break;
        }
}

"Generator methods"
I'm assuming you're talking about re-implementing common framework service implementations, and if so Java has a ton of non-standard techniques to do this that most developers work with. It'd be nice if they were more consistent of the implementation though.

No, I'm talking about the ability to create methods that use the yield return and yield break syntax to implement infinite sequences or just allow me to yield items of a sequence and allow the consumer to process each item as it is produced rather than creating the entire sequence before returning.

http://msdn.microsoft.com/en-us/library/vstudio/9k7k7cf0.aspx

"Async methods (huge!)"
NIO / NIO2 ? I'm not sure what you're referring to. You can write anything you like with things like Runnable or Executor's.

Not even close.

Async/await are language extensions that allow you to write asynchronous code as if it were synchronous. Note how it is NOT about parallel/threads (although that is also a use case) but a much more fundamental concept of asynchronicity. As such you can compose asynchronous calls with branches, loops, try-catch blocks etc. Without such language support you will have to rely on futures/promises that are implemented in separate methods. Thus, you cannot easily loop over such futures/promises as they span method boundaries. Add try-catch blocks to the mix and it becomes unwieldy.

C# async/await solves the problem elegantly and allows you to compose async methods in a straightforward manner.

The big limitation is tail processing in java, but there are third party frameworks that make resuming blocks easier (though not a first class language feature). When you introduce this to a top level, you have to handle what to do with that now parked thread stack and how to clean it up when something bad happens. Its not a trivial problem, but hopefully one that lambda expressions will iron out in Java 8.

You can hope. Meanwhile the problem has been solved in C#: There is no "parked thread stack" as there is no extra thread. Instead the compiler will perform some really clever rewriting and turn your code into a state machine to implement the logical flow while allowing the thread to exit out of the code (to be continued at the same state later).

getting the software to play nice with such a setup is not currently viable ...

It has been viable for over a decade. Plenty of groups have done it:

http://linuxgazette.net/124/smith.html

And Microsoft is jumping on the bandwagon:

http://www.microsoft.com/windows/multipoint/

See the Wiki for more:
https://en.wikipedia.org/wiki/Multiseat_configuration

Most interesting is Fedora 17 automatically enabling it when appropriate hardware is connected, which should mean RHEL7/CentOS7 will, too.

your $50 tablet is actually a fully-fledged computing device.

Yes, but as a "thick-client" it's a brutally low-end and very limited device. As a thin client, it's a high-end workstation, with huge amounts of memory, unlimited storage, etc.

And if a big market ever developed for thin-clients, you can bet these same tablet manufacturers would come out with even cheaper, stripped-down devices that are only good enough to be used as a thin-client. At what price point would you say it's a good idea? $25? $15? $10?

As per Buzer, please refer to, http://technet.microsoft.com/en-us/subscriptions/hh442910.aspx

How do you do something as basic as copy a file securely to another computer? I use scp on Linux.

On Windows it's much simpler. You connect using RDP and then use Ctrl-C and Ctrl-V. The RDP connection itself is encrypted.

RDP? Why not just post your private files on Facebook?

And you do realize that Windows 7/8 stills runs in the exact same manner as Windows Vista, right? And I can still run DOS, Windows 3.x, Windows NT and Windows 95 applications on a stock Windows 8 machine.

The last time I checked on this, an entire suite of programs from pre-Vista would not run on Vista+. Otherwise there wouldn't have been stories like: this or the MS compatibility center which has a not surprising list of software with "Status Varies", the only listing other than "Compatible", and no way to sort on incompatible software. The win16 APIs are only partially functional on Vista+, running in an emulated mode only and with what one person I read at the time described "with less success than WINE". As far as the user context goes, that's a whole different story, and the breakage MS did with W7 / 2008 R2 under the covers was large, if your software played with any of those APIs. Entire segments of functionality are gone, but don't worry - no errors will be thrown, they're just NOOPs now.

Not really. That security hole was patched over four years ago. What does happen is that when removable media is installed, the user is prompted for what to do; this can include opening the folder to view the files, or running a setup file if one is present.

You should read that article more closely. That fixed a bug where the setting to disable autoruns did not work properyl. It still ran if an autorun file was located on the network or some USB devices as I recall, and even more amusingly you needed to set a registry key to enable the patch to work. The default for XP and 2003 is still to run the autoruns unless specifically disabled by group policy or local settings. Win7 does prompt as you describe.

Yes. Whenever windows sees new data from any source, it immediately executes it... for security reasons ya know.

Not really. That security hole was patched over four years ago. What does happen is that when removable media is installed, the user is prompted for what to do; this can include opening the folder to view the files, or running a setup file if one is present. Yes, if someone *chooses* to run the setup.exe file and it's infected, then they can get a virus or trojan. But that's part of the cost of having an open platform without executable signing. The only way to eliminate this risk would be to force the user into a walled garden. That may be feasible on smartphones and tablets, but it's not acceptable on workstations.

I missed that new, thanks. Microsoft really need to update their website. http://windows.microsoft.com/en-gb/internet-explorer/ie-system-requirements#ie=ie-10

As of 2013, the user can attach arbitrary tags to a file and search by tag as well as filename (e.g. "important"). Turns out MS introduced file "comments" with Win XP, although searching by comment was awkward. Vista improved upon it, and of course Win 7 inherited it from Vista.

Oooh. Are you sure you wanna go there? http://www.themacintoshguy.com/mactips/archive/tip14.shtml

Jan 1997. The feature is older, actually, but I'm too lazy to dig further.

As of 2013, the user can attach arbitrary tags to a file and search by tag as well as filename (e.g. "important"). Turns out MS introduced file "comments" with Win XP, although searching by comment was awkward. Vista improved upon it, and of course Win 7 inherited it from Vista.

Oooh. Are you sure you wanna go there? http://www.themacintoshguy.com/mactips/archive/tip14.shtml

Jan 1997. The feature is older, actually, but I'm too lazy to dig further.

Not that easy.

I guess you've never heard of easy transfer.

Yes, it really is that easy. I migrated a friend from an xp desktop to a Win7 laptop (refurbished T500) just a month ago. Plug-em-in, fire it up and go drink the wine and laugh.