Home - LeFreq/Singularity GitHub Wiki
The future of the internet will be peer-to-peer. Mobile devices and the rise of commodity hardware allows everyone to be a publisher of data (and other content), an informer of expertise (and their opinion) -- all on the world stage/arena. With a p2p operating system, people get equality, standardization that allows everything to be shared, interconnected, and built-upon collaboratively. No, it's not pie-in-the-sky talk, but has real computer science to accomplish it all, thanks to the massive work and infrastructure built over the past 80 years. It also has new philosophy and epistemology.
Realize this: the essence of the computer and the network is storing and retrieving data, performing some "simple" transforms on it, and sending the data around. That's it. Perhaps you might add a security layer on all that, but that captures everything at the macro-level, just as Alan Turning described at the micro-level. I say simple transforms, because with a fractal model, these computations can occur at differing levels to create arbitrarily complex transforms without more complexity to the operating system. A grand "theory of everything" you could say, for data and functions.
The platform will also create a brand-new arena for economic participation that doesn't rely on the old industrial model at all. Much like the body's nervous system is distinct from the circulatory system, each provides equivalent but different value, and balance one another. While the industrial model relies on the ideals of the free-market (which needs fixed in our world, so that money forms a true indicator of merit), the internet can use the free-exchange of social currency -- reputation -- through a voting model to create an internet meritocracy. Your reputation will be your bank account on the network. The failure of the existing market system has been evaluated and understood. No need to repeat that problem with the internet.
You'll be dominating instead of being dominated with
- P2P, ISP-free, mesh-radio, device network -- everything can be added to the cloud: POS terminals, smart buildings, cell phones, and desktop servers. Popular objects or data propagate naturally through "reproduction", so that you never need more than a few hops.
- a simple universal, fractal, command-line that scale towards endless, but controlled, complexity to do everything you'll ever need -- more simply than any "desktop" graphical interface will ever be able to do.
- all applications are decomposable to a UniformObjectModel where all objects relate to one another through a simple, general interface (common API), allowing apps to be made by non-technical professionals (much like construction workers build houses or large buildings after they're engineered).
- a meritocratic, decentralized, messaging and data ecosystem in the peer-cloud that gives voice to everyone while ranking those users in relation to the merit decided by the community,
- a full 3D, visualization for your cyberdeck and acoustic feedback system for console events and attention-free interfacing so you don't have to be glued to your device.
"But what about quantum computing???" The processing of a quantum computer, virgins, can be done with classical processors arranged in a hypercube topology for all the problems of your universe. Done. Because it abstracts the process of computation, through objects, this project supports any configuration of processing. The small cost for object-orientated flexibility is made up by superior architecture and far-vaster usability (and re-usability), much like a well-architected building costs more, but saves money and personal headaches over time. We're reaching for elegance, not merely quantifiable benchmarks. So, just shaddup already and click here for example screenshot, boot sequence mock up, or perhaps even a soundtrack...
Your new operating system will elevate your mind, not your system requirements.
Welcome to the Singularity wiki, home to the CONVERGENCE! It quantifies language theory (how to tell computers to do your bidding most efficiently) and structures operating system functions (ordering the execution process and memory storage most efficiently) to create the perfect OS. It also utilizes new epistemology to organize your data and visualize it perfectly. The former are the primary topics of the (computer) science, the rest is information science and philosophy. You can get it all.
This project condenses whole new areas of computer science and opens up whole new philosophy to do so. This plateau is based on several new breakthroughs and a couple of unexploited older ones:
- K-Quotient to quantify language expressivity. If the expressivity of your language isn't more than 1, you'd be better off with machine code. This has led to the concept of a prime language.
- The prime language conjecture claims that all languages eventually gravitate towards an ideal language that satisfies the desire for concreteness and efficiency at the bottom (rejecting purely boutique languages that ignore hardware) while yearning for abstraction and architectural sophistication at the top (rejecting machine commands, though it is technically efficient). This implies that there is only one ideal language for any given architecture (not counting a few cosmetic and syntactical differences) and never a need for another. This alone would save billions of dollars in training, porting, and obsolescence costs. [Update:]
- Ideal Code Size that gives you a target code size for your traditional code bases that will be logarithmically smaller thanks to new epistemology. Theoretically, it always works. It's a theoretical ideal -- the programer just has to figure out how. Hardware call stacks do much of this work already, but since many code bases are a million lines long, we know that there a LOT of improvements to be made. Woot! We're philosophers now! You think you've done the best you can, but now you can measure how close you are to the best. If the hardware is well-designed, your OS can be 4K of high-level source!
- P2P NETWORKING built into the kernel, giving data security (through the peer redundancy like Freenet) and performance gains in new ways and building a perfect, ad hoc, knowledge-sharing community. Clone cool objects and MSG your peer groups. A node peer requirement and simple clone command makes the OS go viral. Just clone your OS onto another interested party and you have another peer!
- Software Data Architecture -- a perfected, uniform API for the few object types to realize a true DataEcosystem because AllDataRelateToOtherData, so why not make a common, object meta-language connecting them together? OOP has gone astray: there aren't that many different object types, so figure them out and make them uniform. All apps are objects, and all objects are apps is the secret sauce. There is hardly another use for object-orientation, but this -- not classical (monolithic) applications.
- Use of sophisticated AudioFeedback, to let your brain focus on other tasks, rather than cogitating on processing written words for I/O from the OS.
- 3d cyberspace visualization. Truly the only way to view the world's exabytes of data perfectly. Throw away the oudated, clunky, desktop metaphor -- this will allow the natural abilities of the visual cortex to process and understand your data and relate to the world in ways that make the 20th Century look.... ancient. No more "word documents", spreadsheets, or databases -- these outmoded, disconnected data stores won't be good enough.
Similarly, most applications are duplicating functionality or creating useless and inefficient data and visual constructs that could be relegated to the operating system, simplified into better information science, or refactored using a whole-systems approach. If the mass of humanity's knowledge can fit in 10Mb, then we can re-imagine the OS and make it much more elegant and fun. Regardless, one of the beauties of this project is to provide a platform for perfectly-organized knowledge so mankind can contribute more efficiently, harmoniously, and creatively towards greater plateaus of human understanding and experience.
STUB Singularity is designed to fill out the landscape that the general-purpose computer (PC revolution) and the Internet have opened up. Well-architected code reduces code complexity by 100 log2 LOC. This is one of the major points of this project: to make a system where such gains can be realized. This is a major breakthrough in understanding code design and has great side benefits besides better code management, like pervasive code re-use and greater performance without more hardware by easier ability to optimize functions/objects that are used by many applications. Why is this so huge? Because if ideas are good, they are re-usable. In fact, this OS is patterned off how the brain organizes the complexity of the body.
The OS is designed to eliminate the mundane, so that you can focus on ever higher and greater levels of ideas. Most applications written in older OS`s have very little relationship to each other, the best you can practically hope for is line-delimited, text files being shared, because things like XML schema are written by engineers, not knowledge architects, and are hardly re-useable. This reduces application usability, and building upon ideas reaches a plateau around Omega(n2) (in the best case: most inter-application use is more like Omega(n log n) because they're not designed for it) from the general-purpose computer`s potential, which is Omega(2n). So, that is a big loss, creating huge memory requirements, processing entropy and heat, many times more programmer time and tech support, and people reach an end-point in their creativity.
A UnifiedObjectArchitecture allows all objects to be "known" by all other programmers. There are no mini domain-specific languages (in which way, the OS is much like LISP). Singularity will create a uniform environment for VonNeumann architectures (Intel and most processors), much like LISP, but is natural for iterative, rather than recursive, computing environments, by using Objects. Get rid of CLOS, what you needed was a new mental model of how software scales.
This project is under development, like a draftsman building a large building: completely architected templates without much code. I don't have the resources to actually code it up right now. But in theory, once the basic building blocks are in place, it should accelerate development into a complete OS dramatically. Most of the heavy lifting is already accomplished with projects like Python, VisualPython, GCC, and the engineering of the Personal Computer itself. In fact, experimentation could be such that people market their own custom ASIC (replacing their BIOS) to have truly personal computers.
Expanding on the GNU philosophy of "help your neighbor", having 50 different OS's is like having 50 different types of gasoline that are incompatible -- simply because brands want identity, not because of the engineering. What would be a "free market" economy is now bogged down by proprietary concerns and domains of control. This is what happens to software. The value goes down by the ratio of the number of incompatible systems. If there are only 5 OSs, it is still 5x less. With the Internet, the value of a "free market" information network is just like the need for standardized transportation in an economy. The value of the whole system goes down when people can't use each other's applications.
We want to make a portable system that runs anywhere. Much like Java was designed, but with a complete DataArchitecture built-in, not just processing language. It's too demanding for all applications to be written from scratch. Applications can now be singular, full-blown, customizable masterpieces, made out of re-useable parts, accomplished with the merger of epistemology and SYSTEMS ARCHITECTURE.
There are four giant arenas, I'll argue, that the general-purpose computer explores (not including more hardware level ideas of control systems or robotics):
- Math (traditional numeric computation and logic)
- Epistemology (knowledge sharing and synthesis)
- Metaphysics (simulation and parameter space exploration)
- Representation of data (visual computing, for example)
From the README. Core philosophies that dictate design aesthetics:
- There are two core RELATIONSHIPS to the machine: application user and Data administrator. Hiding these two necessities makes either users or developers dumb. (-ChromeOS/Surface/Windows10)
- One can get better performance by using better hardware/software ARCHITECTURE rather than requiring MORE hardware/memory. (-Linux/Microsoft/Apple)
- AllDataRelateToOtherData (wikiwikiweb), so make everything an object and make application "mashups" from simpler primitives that relate to that data in all the ways users want, much like unix commands did w/pipes. (-Python, +GPL/POSIX)
- TheNetworkIsTheComputer (Sun Microsystems), so integrate P2P architecture directly in the OS and make a data/app ecosystem. (-Javascript, -file hierarchies)
- All objects exist in a UnifiedDataModel, so all apps draw on these objects re-useing them in many ways. Each app primitive is inspectable. There are no proprietary apps. (+GPL)
- *3D cyberspace visualization* to navigate the 4D hierarchy. 'Nuff said. (+Pangaia/GlassBeadGame Project)
If project development can be broken down into architecture, engineering, construction, and management, then wiki pages with WikiWords are pages which go into engineering docs for the OS. CAPITAL WORDS are high-level, architectural ideas and theory. Everything else is construction and management: in-between until the project is complete.
If you want to get started with the meat of the project, skip to DesignGoals and ImplementationBreakouts.
Imagine the different ways you can scale CPU words (and their different meanings: integer, instruction, pointer, flags, etc.) into higher levels of functions and higher-level data-objects, functions/objects into modules, file modules into projects, etc. Putting that power in the hands of mere mortals is what created the PC revolution and represents Reed's Law value generation: Omega(2n), where n is the number of words. That is the value of the general-purpose computer. Now imagine n people with PCs and you have Omega(n*2n). Imagine these n people in a network (n2) and you have an Omega(nn). Yes, I've equivocated on the number n, but that's for your sake.
That's just to whet your appetite. Presently, we're not getting anywhere near that because of Operating Systems focusing on pretty windows, Jabbascript focusing on commerce and in-bound links to trap user attention (nearly eliminating the value of hypertext), and client-server architecture continuing the model of people as consumers of data rather than as equal peers in a networked environment publishing usable knowledge and information.
Next, let's recognize the tower of abstraction from Computer Science (starting from the highest abstraction):
- USERS
- APPLICATIONS
- Operating Systems
- Digital electronics
- Analog electronics
- Physics and Mechanics (properties of materials)
This project will re-examine basic computer science and engineering, from:
- DataArchitecture (how will the application(s) help the user build knowledge).
- OSArchitecture (application interfaces, buffering software needs with hardware limitations (or vice versa) like allocating processing availability among all nodes -- how to make something useful to the programmer)
- SystemsArchitecture (CPUs, RAM, hard disks, network channels -- how to build something useful for the Computer Scientist),
- ProcessorArchitecture (opcodes and words -- how to calculate -- how to make something useful to the mathematician?),
- ComputerSecurity
See below for the break-out...
Keywords: LanguageAsAnOS, OSIsTheApplication, AllDataRelatesToOtherData, 3DCyberspaceVisualization.
The high-level conceptual divisions for the OS are: PROCESSING, PERSISTENCE, COMMUNICATIONS, USER I/O, and SECURITY.
Applications are re-inventing most of their apps because they don't have common objects that can be built into high-level, generic, mini-apps and re-used. Think of how many useful Unix mini-apps sysadmins made using only a handful of more basic commands. Now expand that to be able to write directly to the screen to make graphic-primitives and pretty soon you have a whole windowing system using a handful of re-used objects (goodbye Gb of memory required!).
Apps are now objects in an Unified Object Model conforming to the Gospel of Data Ecologies. Every object must do something interesting when run and be unique to all others in the system (otherwise, you'd re-use a different object or re-work your object/app architecture). To run the object as an app you 1/YourObjectName run it in the data ecosystem (or traverse into it in the 3D cyberspace visualization).
Everything is customizable, everything is modular, everything is re-useable and open, everything is expandable, every object follows a common language, and pretty soon you can actually realize the Ω(2n) value of the PC revolution (n being the number of words).
Instead of a "file system", you have an ObjectStorageSystem where, rather than a tree of files which has NEVER worked in Unix to create a consistent view of your "data", you have an "object field" (on disk and network) that stores your objects (probably in a hash-like way that maps to your storage space as well as your peers in the network. Much like Freenet architected a data-secure storage system by copying popular files redundantly, the Singularity will relate to other peers and copy objects to keep them secure and available on the network.
Add peer networking to the general purpose computer and you get at least Ω(nn) (n being the number of objects). That's two revolutions being utilized for SingularityOS: the Internet and the PC. Most OSs use the network as a utility for the PC revolution so they can watch more video or download apps on their PC and never get past about Ω(n log n).
The OS is extensible and does not presume a keyboard input. Interaction with the OS might be through a kinetic field holding an object a certain way. The model must utilize a visualization layer that far surpasses anything any other OS has done, because you can't view a 4d graph through a 2d or 3d tree-like structure.
If all this is a bit much for you, steer back to the wiki:OneTruePath.
the Singularity? Well, you could argue that this project will take you to the endpoint and goal of Computer Science itself AND Physics, too, by being the endpoint of data processing (of any kind), scaling to the planet, and in terms of being able to simulate a universe using object primitives.
Security is like the immune system of the OS. Of the 10 commands or so, each one allows you to set who can do the same to your machine.
Anyway, if this sounds interesting to you, click "watch" and follow the project or add a star so others may find it. See acknowledgements for influencers of the project. Thanks!
NOTE: This initiative has perhaps been superseded. The Unix architecture can be slightly updated and perform all of these architectural design goals. Pipes communicate across objects laterally (friends), while < and > communicate upwards and downwards to parents and siblings (or other nodes on the network). A third dimension of order arises from allowing the abstraction of data to go from atomic elements (single numbers) to containers of such items and processed iteratively. These containers can be homogenous and delineated with a special symbol set (), while heterogenous containers can be delineated with another [].
This pretty much encodes the whole wisdom of order for this universe--three dimensions of data transference, plus the operations in Time. You may be seated.