tags:

views:

325

answers:

9

How would things change if a dramatic revolution was made in processor technology with regard to development. For example what if a single cpu was as strong as a cluster? What would happen to security?

+1  A: 

It startring to happen already with cheap multicore CPUs and the ability to build a cluster of cell devices like PS3s to attack encyrption and related.

You need to do as much as possible to prevent power/processing attacks in what you do as much as possible, but at the end of the day there is always a weak point that can typically be brute force attacked given enough power. I beleive MD5 has started to fail as a result.

In terms of general coding, processing power shouldn't be an an excuse for sloppy slow code. Hardware upgrades shouldn't be seen as a silver bullet for poorly designed code.

schooner
+7  A: 

Er, this has happened over and over again many times over the past decades. What has happened is that software has bloated up with features that have little to do with getting work done, but a lot to do with window dressing and bells & whistles.

dwc
There was a law that stated software will always consume more resources than available... can't recall the name of it though
ccook
Are you thinking of the "What Intel Giveth, Microsoft Taketh Away" one? ;)
jalf
While there is a lot of eye-candy, those cycles are also being used to do really work. Interpreted languages are as useful as they are *because* they run on fast CPUs, compilers routinely do time consuming optimizations, offices suits do on the fly spelling checking, etc.
dmckee
dmckee, you make some good points. I didn't mean to imply nothing has gotten better, rather that things haven't gotten as good as one might have expected. And that notion applies directly to the question. We're still struggling with how to effectively use the cores we have.
dwc
Fair enough. It is certainly true that my development machine spends unbelievable amount of power drawing pretty pictures. And it is so insignificant that I don't even resent it.
dmckee
Wirth's law: http://en.wikipedia.org/wiki/Wirth's_law
peterchen
Ahh, thank you peterchen, that has been nagging me
ccook
+5  A: 

If?

If?!?

To a large extent this has been happening steadily for at least 50 years.

The implication for security are a non-starter because they are mostly about programmer practice, and user behavior.

Even the little it of security that is cryptographic is not an issure as long as the current math holds together and we don't see the development of general quantum processors, because:

  • For large-prime based public key systems the state of the art has key generation at a lower order than exhaustive searches.
  • For symmetric ciphers the problems grow at the same speed.

Do take note of the conditions on that claim. Neither is absolutely guaranteed. But losing either breaks the security model at any level of CPU horsepower.


Increasing horsepower has had one big effect on security. When computers came out of the machine room, it because possible for ordinary users to cause huge security holes.

Too bad many of our lowest level tools assume the conditions the obtained before that event, eh?

dmckee
+7  A: 

"For example what if a single cpu was as strong as a cluster? What would happen to security?"

Ahh, kids today. I remember when a processor with a 1MHz clock speed was really something. Now processors are about 2,000 times faster. Disk costs 1/10,000 of what it did. And what has happened is ... well... we have faster, less expensive computers.

What was the question again?

Right. What would happen to security. Security? It's still a problem. It was a problem, it remains a problem.

No matter how fast Windows gets, it still has VBA and Active X controls and other features that are security nightmares.

S.Lott
Well, what if SSL's were easily cracked... would not all traffic become effectively unsecure?
How many sites SHOULD have SSL enabled, but don't? How many people put in plain dictionary passwords? How many sites create dynamic SQL and are prone to SQL injection attacks? Security has almost nothing to do with cracking passwords.
S.Lott
"Security has almost nothing to do with cracking passwords." Right. And where it does, it can be made harder *at least as fast* as the resources to attack it grows. Oh, we'll need SSLv.N, but so what?
dmckee
*nod* Indeed... I still remember my first hard drive. Roughly the size of a modern set-top box and it held a whopping *12 megabytes*! I thought that'd be all the space I'd need for life. Now I've got 20 times the storage on a chip the size of my fingernail... and it's always full.
Dave Sherohman
"I still remember my first hard drive" - Hard Drive? LOL ... floppy disks were 80K. People were impressed because our application required a machine with 4 drives instead of the customary 2 drives. We flew to New York to get RAM 'coz it was cheaper, including flight, than buying in UK
Kristen
+1  A: 

In my view this is happening already with quad core's, cheap memory and virtualization.
This is allowing the number of servers in organization to be radically reduced, decreasing a signifcant cost quite rapidly.

This is going to mean that other costs, like staffing, and networking are going to be seen as more expensive comparitively, which will probably drive down the prices of those items too.

Take for example one company which can move from 150 servers, to 10 servers. Thus decreasing associated hardware ,networking and maintenance costs.

Then think of the software which runs on it, the licencing of it, and the salaries of the people who look after those applications.

I would think that people are going to have to justify what they spend on software and consulting fees much more carefully in future.

Bravax
+3  A: 

You just increase the size of keys in common use.

+2  A: 

How would things change if a dramatic revolution was made in processor technology with regard to development.

It's happening as we speak. Multi-core processors require changes to programming style that current programming languages are still adapting to.

Ever wonder why new programming languages are quick to tout their concurrency support? It's because programming language revolutions happen with hardware changes and they know it. Don't believe me? Think about the big programming language changes:

  • FORTRAN and COBOL became popular with the advent of mainframes.
  • PASCAL and C became popular with the advent of mini computers.
  • C++ became popular with the advent of micro computers
  • Java became popular with the advent of the internet.

Whatever the next big programming language will be will probably have really good concurrency support.

Jason Baker
+2  A: 

Ha. When I was a poor graduate student I did some work at Edinburgh University on one of the world's first massively multi-processor machine. The Distributed Array Processor. This was back in 1981. We used to talk endlessly about how powerful it was and what it could do, cutting edge computing and all that (we were comparing biological protein and dna sequences)

That was long ago. Last year I went to a public talk about the history of supercomputers at Edinburgh. They mentioned the DAP, but started doing comparisons to present day computing power with it's successor.

And guess how powerful that was, compared to a modern day machine? .
.
.
.
.
.
.
.
.
.
.
.
.
.
.
A Playstation 2.

Cruachan
+2  A: 

Hasn't this already happened?
CPU cycles are now by far the cheapest ressource. Memory access costs dozens to hundreds of CPU cycles, access to hardware or disk thousands. Most consumer applications only marginally benefit of a faster CPU.

I still remember the days where we were counting clock cycles, and saving ten cycles by using 1k more code was a clever idea.

What usually happens is that new architectures take the new balance as a given: new languages, new libraries, new platforms. Most code written today is - conciously or unconciously - written under the assumption that cycles are cheap, memory access is not. That's true for both application and platform code.

The next major change seems to be parallelization: future code will be written under the assumption that cycles are even cheaper when it access private (rather than shared) data.

peterchen