Home

Show your dominance with 1) Networking [radio]
network, 2) a command-line, UnifiedObjectModel,
[DataEcosystem], 3) UnifiedObjectModel
[ObjectStorageSystem] kept secure through peer redundancy, and 4) a
CYBERSPACE and no one can cut you down.
You'll be making money by making cool mash-ups. "But what about quantum
computing???" The processing of a quantum computer can be done with classical
processors arranged in a hypercube topology for all problems of this universe.
Done. Because it abstracts the process of computation, 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), so just shaddup and click here for 3D VISUALIZATION
MODEL or bootup...

Welcome to the Singularity wiki, home to the [CONVERGENCE]! How/What? It
quantifies Prime (how to tell computers to do your bidding
most efficiently) and OS theory (how to structure
the execution process most efficiently), plus how to
UnifiedDataModel and CYBERSPACE. The
former are the primary topics of the (computer) science, the rest is
[information science] and Metaphysics. Here, you get it all.

This project condenses whole new areas of [Computer Science] and opens up
whole information science to do so. This plateau is based
on several new breakthroughs and a couple of unexploited older ones:

• Kolmogorov 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 expressivity 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: The exception to this is rapid prototyping vs. efficiency?]
• SoftwareArchitecture that gives you a target LOC 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. 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!
• peer-to-peer [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!
• GOOP -- a all objects 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 all objects, 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 OOP, 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.
• CYBERSPACE. Truly the only way to view the world's exabytes of data perfectly. Throw away the oudated, clunky, desktop metaphor -- this will allow the search context 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.

Posit: The bulk of humanity encodes an estimated 10Mbytes of general
knowledge. Since the internet is using 100Terabytes (or over a 100 million
megabytes), one can conclude that the internet is currently organized (and
mankind, by association) inefficiently at a rate of 1,000,000:1 of wasted
storage, communications, and processing. Before you conclude that this is a
pessimistic estimate of how much mankind knows, think of the game "20
questions". With this game you can pinpoint between a million selections with
only 20 bits or less of knowledge. But this is 10Mb = 80 million bits -- a
safe estimate. When you consider the amount in which people follow another`s
order of knowledge (like science or religion), the actual amount of real
knowledge in (present) humanity is very low, this estimate puts it at less
than 800 bits per person.

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 epistemology,
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. SYSTEMS
ARCHITECTURE reduces code complexity by 100 log2
[LOC]. This is one of the major points of this project: to make
DataEcosystem 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 biomimicry.

The OS is designed to eliminate the mundane, so that you can focus on ever
higher and greater levels of bliss. Most applications written in
older OSs 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 computers 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 GOOP. Get rid of CLOS, what you needed was a new mental
model of how software scales.

This project is under ideals, 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
Gospel of Data Ecologies 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 ideals, 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)

An OS can optimize any three of them in a uniform way, otherwise one must
resort to sub processors or inefficiency. This OS chooses the first three and
offloads the last to dedicated GPU(s).

From the README. Core philosophies that dictate design aesthetics:

1. 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)
2. One can get better performance by using better hardware/software [ARCHITECTURE] rather than requiring MORE hardware/memory. (-Linux/Microsoft/Apple)
3. 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)
4. TheNetworkIsTheComputer (Sun Microsystems), so integrate [P2P] architecture directly in the OS and make a data/app ecosystem. (-Javascript, -file hierarchies)
5. 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)
6. [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.

Why Singularity 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
peer-2-peer 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 will be important, because we'll be amping up each these to another
level.

This project will re-examine basic philosophy, 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]

This project is focused on creating a system to maximize KNOWLEDGE (and
organize it), while making it extremely easy to make applications to do
EVERYTHING ELSE. In fact, we can ditch the compilation step and print
optimized ASICs holding your object/function, data-flow-processing graph.
[RAD]ical!

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.

• Kernel:
• Memory:
• Networking:
• USER I O:
• SECURITY

Kernel:

Applications are re-inventing most of their apps because they don't have
Unified Object Model 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]).

Memory:

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 peer-to-peer 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.

Networking:

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).

[USER I O]:

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 3D Visualization Model 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 fractal graph (of any kind), scaling to the
planet, and in terms of being able to simulate a universe using Unified
Object Model primitives.

[SECURITY]

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