The iPad has a real chance at making things like this more 'intuitive', but I've watched my wife struggle with simple tasks on her iPod touch. She's very smart (PhD!), but her mind just doesn't take to working in virtual spaces.

An example: keeping a mental model of location within a document. She can handle that with paper quite easily, but doing it on a computer requires enough concentration to take her out of the original task.

Ahh - the red pen interface. Combine it a bit with sticky notes, and you're done. Easy to understand, easily transported.

You'll probably get a few more posts suggesting laptops and tablets, but using those requires a significant investment in self-training and practice. That's something us geeks have forgotten, since we got past that point a long time ago.

I'm not sure how it could be extrapolated to a more general case...

Well, why not watch the video then?

Thank you for your pointless, pedantic answer.

There's a reason you (and every other proponent on this thread) are not providing any answers, and just keep saying 'watch the video'.

Because there isn't an answer.

The video isn't presenting a 'better way to program'. It's presenting a way to enter parameters for a specific set of circumstances. If you've written the simulator for that set of circumstances. Which is the hard part.

Thanks for the link - that is interesting.

But ... it's a demo of an interesting tool for solving a specific problem. I'm not sure how it could be extrapolated to a more general case, and the 'tools and implementation' appendix doesn't give any details.

Cool story!

Well, here on Slashdot it's a cool story - anywhere else, it would probably come off as a bit crazy :-).

Yeah, if you can isolate the AGPL code somehow, you've got a pretty good case for limiting the scope of 'modified code'.

It gets complicated when the AGPL code is a library that you want to link into your code. See my post below for an example of how that might play out.

An example of the downside of the AGPL:

You're running a website that's a discussion forum. You find a tiff-to-jpeg library that you want to use to convert member's avatar photos, so you call the library's 'convert' method.

Congratulations, you've just created a modification. Since the library was licensed under the AGPL, you now need to:

• - release the code that calls the API.
• - release the code that calls the code that calls the API.
• - release any other code called by the code that calls the code that calls the API.
• - release your build scripts
• - release source for any other libraries you've invoked. That includes anything you purchased from a vendor.
• - etc. You pretty much have to release your entire web site.

Now, you may not have any philosophical objections to releasing everything listed above, but just the logistics of determining the licenses of the existing source code could be enough to kill the idea.

Note that this example is not completely theoretical. </dontaskmehowiknowthis>

That's basically it, but note that 'source code' could be interpreted as every last line of code for your web site.

It's part of the murkiness in trying to describe 'modification'. Does that mean code that you've added to the original? When does that stop?

Limiting the definition of modification is the main point of the LGPL. But there isn't an LGPL-like variation of the Affero license. And without that, there are a number of situations where AGPL code is simply unusable, regardless of whether you make any changes.

Jury 'nullification', not 'notification'. There's quite a bit of history there, and not all of it is good; nullification has often been used as a tool to suppress dissent and minorities.

Schneier covers your point on the increasing rate of attack possibilities. You can see some hint of the discussion in the last diagram on this page of figures.

Read the book - this is exactly one of Schneier's points.

It's even covered in the available-on-the-web Chapter 1.

Scale is still a problem ... for every source, s/he'll have to

• - move them into test mode
• - change their NTP source
• - run the test
• - undo the configuration changes
• - hope the system doesn't change between the test and the time they need the result.

Chances are many of the source systems belong to customers, suppliers and other third parties. Coordinating the testing would be complicated. Tracking the configuration would be even more complicated.

It'll be a lot cheaper for him to take a couple of minutes of outage every few years.

Some quick notes.

• - You are replying to the wrong guy.
• - That guy could change his contract, but that won't fix the problem: adapting to leap seconds is unnecessarily expensive.
• - The guys that you are planning to email already know there's an issue, and are voting on whether to eliminate leap seconds: http://www.slate.com/articles/health_and_science/new_scientist/2011/12/leap_seconds_and_the_problem_with_the_global_time_standard.html

I think the original poster's problems are on a scale much larger than 'fix your software'. He/she is getting data from multiple, disparate systems, and probably does not have any way to tell if a given source supports leap seconds or not. Without that info, there really isn't a fix available.

As usual, Glenn Greenwald has covered 'twitter terrorism' and other parts of the never-ending war in all its absurdity: http://www.salon.com/2011/12/20/the_u_s_government_targets_twitter_terrorism/singleton/