What are your OS goals?

[Muazzam]

I think every OS developer have any "specific" goals for their operating system. My goal is: I went to make an Operating system with Unique GUI, operating system will run every program in "full screen" such as Windows 8/8.1. I also went to implement audio/video and multimedia support. I'm also not going to copy UNIX/Linux. What are your goals? Describe below.
-Muazzam

[fluray]

No specific goals, usually makes me interested to see what will be added to the OS.

[Brendan]

Hi,

What are your goals? Describe below.

My goals are:

• to see how much better things could be if everything was designed from scratch for modern systems, with no regard for compatibility with anything
• to create a distributed system where no computer has a pre-defined role (not "client server", where some computers are file system, some are processing, some are user input/output)
• eventual/potential support for a wide variety of platforms (e.g. so that a single distributed system could include 32-bit 80x86, 64-bit 80x86, ARM, PowerPC, etc; where normal processes don't need to know or care what the underlying hardware they're using is)
• significant improvements in fault tolerance; partly because the chance of hardware failures depends on the number of computers in a system - e.g. if one computer fails after 3 years on average, then with 75 computers you can expect one to fail every 2 weeks on average.

I want to see an office for 9 people where instead of having 10 computers (one for each person plus a server, where each computer is only doing something 10% of the time) there's only 3 computers (where each computer has 3 keyboards, 3 monitors, etc, and is doing something 30% of the time).

If I'm working on something in my computer room; then (with about 2 mouse clicks and nothing more) I want to be able to send my entire GUI (including all its running application's windows, etc) to a computer in my lounge room and continue using all those applications. Then I want to be able to transfer 2 of the applications from my lounge computer to a laptop, get on a plane and continue using those applications during a 2 hour flight. After landing I want it to auto-sync with the computers back in my house (over the Internet). Then I want to be able to smash the laptop into 1000 pieces, buy a new laptop, install my OS on it, add the new laptop to my cluster of computers, and find that everything is exactly how I left it (including all the files I modified during the flight) and that all my applications don't need to reinstalled at all.


Cheers,

Brendan

[Love4Boobies]

Mine is to earn money to buy an island.

[vtsman]

My goal, as absurd as it is, is to be completely computationally independent. Basically, to me, that means I have a sufficient software library i.e. emulators, gcc, a web browser, a network stack and possibly a usb stack, and then to create custom hardware to run it on. Said hardware would be something akin to the open novena platform.

[bluemoon]

[*]to create a distributed system where no computer has a pre-defined role (not "client server", where some computers are file system, some are processing, some are user input/output)

Interesting, one of my non-osdev research project is server-less distributed architecture, however using traditional computers and OS.

[Muazzam]

Mine is to earn money to buy an island.

No matter you work hard day and night on your OS project, you can't earn money from it .
If you went money, Develop apps (android, IOS, windows 8 apps etc.) "NOT" Operating system.

[bluemoon]

Mine is to earn money to buy an island.

No matter you work hard day and night on your OS project, you can't earn money from it .
If you went money, Develop apps (android, IOS, windows 8 apps etc.) "NOT" Operating system.

Nah, you hardly earn enough money to buy island by developing anything,
note that if you develop things that sell to Google/Facebook and become billionaire, you earn money by selling business, not by developing.

Back on to topic, my primary goal is to comfort my curious on knowledge.

[embryo]

• to create a distributed system where no computer has a pre-defined role (not "client server", where some computers are file system, some are processing, some are user input/output)
• eventual/potential support for a wide variety of platforms (e.g. so that a single distributed system could include 32-bit 80x86, 64-bit 80x86, ARM, PowerPC, etc; where normal processes don't need to know or care what the underlying hardware they're using is)
• significant improvements in fault tolerance; partly because the chance of hardware failures depends on the number of computers in a system - e.g. if one computer fails after 3 years on average, then with 75 computers you can expect one to fail every 2 weeks on average.

Almost all of the goals above are the application level goals. Distributed systems like yours are well known as peer to peer networks, an OS is irrelevant here. Support for many platforms was implemented by Sun in it's JVMs. Fault tolerance is implemented using RAID-like approach, which actively uses drivers, but is not OS dependent. Even mentioned screen transition from one station to another is implemented with solutions like remote desktop.

Actually an OS is important for performance tuning. It can be interesting as a service provider, but here we have to compete with application layer and again, the advantage of OS based solution is still with performance, because everything else can be implemented in the application layer. I hardly imagine anything outside the performance where an OS can beat an application.

[iansjack]

Mine is to earn money to buy an island.

No matter you work hard day and night on your OS project, you can't earn money from it .
If you went money, Develop apps (android, IOS, windows 8 apps etc.) "NOT" Operating system.

It appears that no-one told Bill Gates that simple truth.

[DVicthor]

To be simple without too much bloat, and with a cool (T)(G)UI and CLI, don't forget easy to use and well-documented API, and also to satisfy my curiosity.

[DavidCooper]

I wanted a simple, stable platform for working on top of where I would know that any bug that turned up would always be my own fault, and where I would be able to fix it myself. I also wanted a programming environment that suits the way I want to program, because I hate programming languages and don't want to be imprisoned by other people's complex systems and arbitrary notations. I wanted the OS to be free of unnecessary clutter and distractions too. The most important thing though was that I wanted an operating system that could be modified from within itself such that it could be developed without depending on any external software, and the big aim is to build intelligent software on top of it which can write new code by itself and do such things as modify the OS to add all the features that other OSes have without me having to do the work myself.

I am obviously not at that stage yet, but am currently following an unexpected path which involves doing something highly counterintuitive, because it depends on writing extremely slow code which does things in a highly inefficient way, and yet I now think this may turn out to be a vital step towards creating human-level intelligence in a machine. Once a piece of code works, it can be hacked down to the minimum and optimised, at which point it can become the fastest possible code to carry out a specialised task, but the key to writing it in the first place is for it to be mind-numbingly slow, because it must initially be carried out by running a finite set of simple, universal problem-solving algorithms. This is like the way that humans (we ourselves are universal problem-solving machines) learn new skills, applying simple, standard algorithms which serve as the first working version of any program needed to carry out any task, but then the specific program for the required task is gradually extracted from that clunky conscious one and turned into a highly refined automated version which is carried out non-consciously and at lightning speed with everything superfluous stripped out of it. So, once the full set of simple, universal problem-solving algorithms is identified and put in place, the machine running it should automatically become an AGI system, learning how to do more and more things by turning natural langauge instructions into refined program code after going through a slow step in which it runs the natural language instructions much more directly, just as we do when following instructions given to us by another person, and the machine will rapidly build up a set of skills to handle more and more complex tasks efficiently. A lot still depends on the instructions being well put together in the first place, but the machine should be able to spot problems in the same way a person does and ask for clarification on all the awkward points relating to exactly where a particular course of action should be triggered. The key to it all though is how to unpick the natural language instructions and keep breaking them down until every component part of an instruction can be handled by one of the universal algorithms which is already in place in the machine and ready to deal with it. As soon as all natural language instructions can be handled in this way, it will be game over for all other programming methods, because anyone who can formulate clear instructions in a human language will be able to do the job without having any programming expertise at all, and the end result will be the best possible code because the machine will be the expert in optimising code. This is still not an easy thing to build though, for however simple the set of universal problem-solving algorithms turns out to be, there are still enormous complications in handling natural language, though I think I may already have done all the work necessary in that area. Of course, some people imagine that the system I'm building will depend on magic in numerous places, but that is not the case: it is 100% mechanistic and the task of designing it has been in working out all the mechanisms, but I don't mind attracting ridicule as it will only make it much more fun on the day of the reveal.

[embryo]

I also wanted a programming environment that suits the way I want to program, because I hate programming languages and don't want to be imprisoned by other people's complex systems and arbitrary notations.

But you are still imprisoned by hardware designers. Processor instructions in binary form also lock you within an arbitrary notation, expressed in ones and zeros, and every new processor introduces new notation.

and the big aim is to build intelligent software on top of it which can write new code by itself and do such things as modify the OS to add all the features that other OSes have without me having to do the work myself.

Great goal! I hope you have some success on the way.

I am obviously not at that stage yet, but am currently following an unexpected path which involves doing something highly counterintuitive, because it depends on writing extremely slow code which does things in a highly inefficient way, and yet I now think this may turn out to be a vital step towards creating human-level intelligence in a machine. Once a piece of code works, it can be hacked down to the minimum and optimised, at which point it can become the fastest possible code to carry out a specialised task

Yes, that's exactly how quick prototyping works.

So, once the full set of simple, universal problem-solving algorithms is identified and put in place, the machine running it should automatically become an AGI system

The only problem here - we should identify the required set completely. It's a biggest problem. And one point - each algorithm can be simple, but entire system can be very complex.

The key to it all though is how to unpick the natural language instructions and keep breaking them down until every component part of an instruction can be handled by one of the universal algorithms which is already in place in the machine and ready to deal with it. As soon as all natural language instructions can be handled in this way, it will be game over for all other programming methods

Yes, but it means we should wait until real AI will be implemented. Until such point we should have no tools to simplify our work. At least it is your suggestion. But may be you have already managed to go without traditional tools and implemented your personal set of tools which works exactly as the traditional one. But is it efficient to re-implement everything?

[DavidCooper]

But you are still imprisoned by hardware designers. Processor instructions in binary form also lock you within an arbitrary notation, expressed in ones and zeros, and every new processor introduces new notation.

That's true, but I find it easier to work with the machine instructions directly rather than having to handle another layer of complexity on top. I suffer from a mental block when it comes to working at higher levels, until it goes to the opposite extreme with natural language.

The only problem here - we should identify the required set completely. It's a biggest problem. And one point - each algorithm can be simple, but entire system can be very complex.

But most of it is just about taking instructions in from the outside and implementing them, and it may even be that all of it is about that. The rest of the problem of creating intelligence may be no different, because when we think independently and come up with new ideas, we are primarily (or perhaps doing nothing but) running programs that have been trained into us from the outside. Children are trained both deliberately and by accident in how to solve problems, and they collect a set of such skills which they can then employ to innovate in any area, though some obviously learn to do it better than others (perhaps because they are better able to learn - that seems to be the main thing that affects human intelligence, because there's nothing specific that less intelligent people aren't capable of doing if they work at it for long enough). The first step though is not to worry about the innovation side and just to focus on taking natural language instructions and finding ways to run them as program code, because it is that process that these universal rules are there for - they are not used for general thinking. Once you have programmed the machine to be able to handle all input of that kind, then you can turn your attention to telling it how to go about thinking for itself, training it to look for problems and to try to work out how they might be solved. Most people never innovate, after all, but merely become good (or bad) at running more mundane programs to do exactly the same things as everyone else.

The key to it all though is how to unpick the natural language instructions and keep breaking them down until every component part of an instruction can be handled by one of the universal algorithms which is already in place in the machine and ready to deal with it. As soon as all natural language instructions can be handled in this way, it will be game over for all other programming methods

Yes, but it means we should wait until real AI will be implemented. Until such point we should have no tools to simplify our work.

What I'm suggesting is that it is by doing this work that AI gets implemented, so there is no point in sitting back and waiting for it to be done before doing it. By writing an interpreter to run natural language programs, I think it will take us straight to AGI. It will lead to a way of programming where you create programs by holding a conversation with the machine while the machine guides the process by asking how each part of the program is to be broken down into smaller steps. Then when it runs, it can be run slowly and allow the human to comment on how it's going and to modify the program along the way. This may be close to what people are already doing in the highest level programming languages, of course, but the speed of writing programs is still held back enormously simply because everything has to be done through a programming language rather than normal human language.

At least it is your suggestion. But may be you have already managed to go without traditional tools and implemented your personal set of tools which works exactly as the traditional one. But is it efficient to re-implement everything?

I've built tools that allow me to work the way I want to work, but other people who are happy with the tools they use are really at no disadvantage. I thought from the start that AGI would write machine code directly and that I should do the same, but the real program is written in your head at the highest level no matter how you write your program code, and it's going to be exactly the same for AGI. AGI will convert from that directly into machine code without fiddling around at any levels in between, but there's absolutely nothing special about the machine code level other than that processors understand it (though with x86 it all gets changed again before the processor runs it anyway). Ideally programming would be done in an artificial langauge with as much ambiguity removed from it as possible, but that would be the same level as natural languages as it could be spoken as a fully practical means of ordinary communication between humans. Even so, natural langauges won't be much slower as we know well enough what the ambiguities are and when they occur in our speech, and we generally clarify what we say as we go along to remove them whenever it's necessary to spell out which meaning is intended. Within our heads though, we think in something like a language, but it lacks ambiguities. The machine will need to do the same, translating input from the outside into the unambiguous internal form, asking for clarifications about the intended meaning wherever the human doesn't provide them automatically. As soon as it can run the internalised ambiguity-free version of the natural language program with the set of universal problem solving routines, the task of understanding what the machine is being asked to do has been understood. It may not work the way the human intended, of course, but the human can then watch the program run and object to what it's doing, then the machine will present to the human the part of the program where things probably went wrong, and the rules that the program is applying will be spelt out right there in natural language form, making it easy for the human to understand what is causing the problem. Even the comments will be treated as part of the source code and the machine will object if they don't match up with the natural language instructions.

The speed gains in being able to program in natural language are obvious, but the biggest speed gains will be when you can say things like "do it the same way as you do when doing that" and the machine can work out what it is that it does in one program that you want it to do in the new one. It may then need to ask you to spell out what it is that it does in that program that you want it to do in the new one and exactly how that relates to the data it's manipulating in the new program, but it will allow you to spell out the program in the most economical way possible, anything that the machine manages to work out directly saving you the trouble of spelling things out in greater detail. The intelligence required by the machine to be able to make sense of such instructions may be possible to program into it simply by telling it how to go about interpreting things: when someone tells you to do something the same way as you do with something else, you look for similarities in the tasks and try to work out which things are being equated. To try to work out which things are being equated, you can look at previous experience and see which things have most often been equated in the past. That requires an experience database to be kept, but it would be created and maintained by running another learned program. The whole of intelligence is just the application of rules or programs, and the order in which the programs are applied is itself determined by running a program. Where it doesn't work out, it means one (or more) of those programs isn't as good as it could be, but all of them can be modified, and the intelligent system can itself modify them experimentally, guided by advice and suggestions from the outside. Well, modifying some of them could break the system and make it worse, so you'd need an undo function for that.

Clearly it's still a major task to make this a reality, but it's what I got involved in OS dev to try to do. Before that I worked in linguistics (studying the grammar of dozens of languages and trying to work out what the underlying thought structures were, plus breaking down thousands of words into the fundamental components of meaning that lie behind them) and realised that my work there was directly relevant to the development of AGI, but I knew nothing about programming at that time. Half the battle since then has been in trying to work out the right direction to take, but bit by bit it has become clearer what the actual task is and how it might be solved. Most of the work I've been doing has been going in the right direction, but it's only recently that I've been able to see clearly how actual thinking works and exactly what intelligence is.

I really need to ban myself from using the Internet though so that I can get on with building it.

[b.zaar]

If I'm working on something in my computer room; then (with about 2 mouse clicks and nothing more) I want to be able to send my entire GUI (including all its running application's windows, etc) to a computer in my lounge room and continue using all those applications. Then I want to be able to transfer 2 of the applications from my lounge computer to a laptop, get on a plane and continue using those applications during a 2 hour flight. After landing I want it to auto-sync with the computers back in my house (over the Internet). Then I want to be able to smash the laptop into 1000 pieces, buy a new laptop, install my OS on it, add the new laptop to my cluster of computers, and find that everything is exactly how I left it (including all the files I modified during the flight) and that all my applications don't need to reinstalled at all.

I want this ^^^ except without the broken laptop part.

My main goal is to have a minimal OS. The Kernel and drivers could run on something as small as a mobile phone right through to a cluster server with only the drivers being the main difference. The service calls to the kernel wouldn't be many, most of the extra functionality would be added through drivers and then libraries. I also want jailed environments. An app written for a 32 bit machine would know it is running in a 32 bit 386+ environment and could play with the screen memory, sound card etc directly as if it were the only active app on the machine (Think DOS or a VM). Or it could run everything through libraries or system calls as if it were running on any 32 bit CPU in existence just knowing that every register/memory address is 32 bits wide (Think linux). A 32 bit app could run on a 64 OS as the environment would be set up as a pure 32 system (WoW64). This last part might even handle 16 bit code using Pm86 on a 32 bit or 64 Bit OS.

The programming interface for GUI apps would be a little simpler too. I'm not sure about final details yet but I'd like the structure to be almost the same as writing a simple procedural app with only little modification.

Very long term goal, have the jailed environments emulate other OSes like DOS Box, Lin Box or Wine. The app could be started directly and the OS would open it as a document to the supported emulator, like double clicking a .txt opens your editor. The emulation would appear transparent an to the average user (Mum/Dad/Boss) and the app would appear to be a native app without even having the DOS box logo, border, or anything else to distinguish it as different.