Idea #3: How to start a new OS

Starting a new operating system is damn close to impossible. Mostly because of these things:

• Drivers


• Program compatibility


• Untested security

The last is inevitable. However, a new OS would allow you to use modern security architecture that over time could actually help make things more secure. One recent OS that has decidedly caught on: android.

The other two are harder.

Android decided to use the linux kernel, probably to help with the driver issues. It kept a java-esce programming language to ease developers in and help make programs SOMEWHAT compatible-- it blew away the archaic and ugly java view/model/event layer with its custom GUI layer (now the cause of a lawsuit).
The other issue is this: Existing operating systems are usually good enough. Exceptions in the past: DOS (hardware changes allowed better security), Windows XP (security architecture problems-- not really solved in vista/7, but the new one is better).

Well why would you even want to make one?

• Fun


• Serve a new need (embedded, touch screens, 3D, frequently adding/vanishing resources, reads your mind, injects thoughts into your mind, needs to be distributed, fault tolerant, etc)


• Security through obscurity (or failsafe/stopgap in case of a compromised OS)


• Performance


• Easier for programmers and/or users

So android started for all of the above. Same with iOS.

I'd love to see a distributed one-- the same "computer" runs at work, home, the cloud, from any PC and resources can be randomly connected/disconnected with no problems. Maybe a smart gui could carry the same program on my phone to my desktop with minimal loss of functionality. This would be ridiculously hard though.

Also if you could actually grow computers (which are crazy inexpensive, can be made locally, but they fail a lot), a fault tolerant distributed system would be awesome. Ya know, like our brains.

Idea #2: Constraint Based GUIs

GUIs are hard.

Not hard to learn. Hard to do what you want.

When I was doing CAD in High School I found Inventor. It offered constraint based modeling-- one of the best things ever (AutoCAD feels silly afterwards). It let me know if my system was over constrained or under-constrained, which is great for a new designer. It also lets you take the least measurements needed (just sketch things up, constrain the shape, then start doings specifying some lengths!).

I haven't found a GUI that does something similar.

You could have constraints like "Text size must be readable"... which means different things to different people.

You could have constraints like absolute positioning or this box must contain some other box.

This would only be good for structure, not content or styling!

Best of all you can detect over/under constrained problems... before it looks ugly! I suppose it could warn you on the minimum screen size needed as well (maybe switch skins based on constraints)!

Non-exhaustive list of possible constraints:

contains all of _
is contained by _
does not overlap
does not rotate
southwest of _
east of _
is _ degrees/radians from _
's center is _ degrees/radians from center of _
always shows
attached to _
cannot be resized
takes up the maximum size
takes up the minimum size
takes up _
is bounded by a rectangle [_ by _]
is bounded by a circle [with radius/diameter _]
has a buffer of _ [[around it]/[inside it]]
has a readable color
smallest readable by user
bigger than _ by _
repeats _ by _ (infinity is valid)
may repeat _

Example:

BlogPost contains Menu, EditBox, Buttons, and ReturnLink
BlogPost takes up maximum screen
Menu at top
EditBox south of MenuBox
Buttons south of EditBox
ReturnLink south of Buttons
Menu,EditBox,Buttons,ReturnLink want to be West, want to take up the minimum size, and do not overlap.


So on and so forth.

For the style, you'd have to uniquely name everything. I suppose I left out repeating blocks.

This could be really interesting as something modeled this way could literally have a image floating around the screen as the text moves around it. It would also make it much easier for moving of components from somewhere else.

I'd probably copy the syntax of this from haml, the most beautiful of the sgml producing formatting languages.

Idea #1: Peer reviewed blogging

Everyone knows of digg, slashdot, and others where people submit stories and people vote them up down and provide commentary.

The first group to do this was academia. They would submit articles to committees, who would review them, and choose to publish them in their prestigious journal-- or not.

Crowdsurfing does cool things, but it serves the common denominator.

I think a better model might be to have the people that actually submit stories get reviewed by 6 other people. In turn for a chance to have your article reviewed you review 6 other peoples and say yes or no. By review I mean thumb and article up or down.

Normally this would develop a culture where everyone thumbs everyone else up. However, here's the twist. You can only thumb half of them up. The more your rating varies from 50%, the less you are weighted. The more highly others rank your articles, the more your articles are rated.

Another aspect to your score might be the score readers give your articles, your tags, and how many readers articles you support or write garner!

Just an idea.