Open Source Ecology Forums

MasonB

A quick introduction since this is my first post I am a Computer Science
graduate student who is interested in open source and the
representation of information (Which for me often ties into programming
languages, but OSE got me thinking about something different).

I may be thinking way too far into the future but I feel like this
project could eventually use a better way to store information about the
design, production, and maintenance of machines, about techniques for
designing and building structures and other machines, about local raw
materials (including foods) and how to identify and prepare them.

For starters, parts of this information will be localized. An OSE group
in Alaska is going to have different requirements than one in Africa,
they are going to design different solutions and come up with techniques
that pull in local materials and knowledge. They will have different
local foods, and different ways of cooking them. Also, different people
will have different thoughts on how to do something, this is natural,
but it means a digital blacksmith (I really enjoyed that list of job
openings and their titles) in one OSE group may tweak a design to do
something slightly differently, or use more local materials, or be
slightly better at it's job. And the final thing is that open source
never stops evolving, if this project is successful, in a hundred years
do you think people will stop tweaking the tractor? In a thousand
years?, in eight thousand years? The answer is of course not. The goals
of this project seem to mandate that all of this information be recorded
for the use of others in the future, yet I don't think it is prepared
to capture all of the information that will be produced by this project.

And the point I am getting to is that a wiki linking against google and
other free cloud services is not enough, you need a specialized
distributed version control system, something like git but designed with
something besides text based documents in mind, and with better
integration on the concept of user. Something which can run queries like
wolfram alpha, but provides information like a wiki, and which can
understand that there may be more than one version of something. Also a
interesting part of git is that it is designed to be local, each OSE
group would have their own repository of information, it would be local
to that area.

Why is this better than the way it is now? Because a local repository
doesn't disappear with the internet, infact it's designed to keep
running without it. And with the volume of information we are eventually
talking about passing a harddrive around will be easier then sending it
over the internet to another country. And besides, you can still access
and update against other repositories using the internet.

Like I said I may think to far into the future. (In fact here's a link to a short story about me thinking to far into the future about the OSE project.
[Writing helps me relax]) But I feel like a plain old mediawiki can't
hope to capture all of the information you, and those groups who come
after you, will create. And I just wanted to start you guys thinking on that.

Edit: This thread is actually a lot of what I am talking about! (Didn't see it before)

Matt_Maier

Yeah...

So far the best thing I can think of is to either adopt or invent a hardware description language (HDL). They're used to program FPGAs and DARPA is working on some kind of HDL for their adaptive vehicle make project.

However, I'm not sure if that's really a practical idea. I think it is. I think it's just a matter of writing the language and then writing a higher level development environment as a human interface. In theory, with the right language, you could describe pretty much any arbitrary combination of objects. FPGAs work. Understanding how they're programmed and how the program is executed is...hard, but some people can do it. Anywho, with a functional HDL you could compare changes and track forks without any problems.

Short of that, a similar idea is that we need a 3D modeling program that forces the modeler to work only with operations that can be carried out in real life. Rather then let the modeler define any shape they want with just some math, the program should make them load real-life raw materials, then tools, then manipulate the tools to create the final object. The process should include enforced workspace constraints. If they want to use a drill press, but there's no room to get the part onto a drill press, then they can't perform the operation. Something like that would ensure that instructions for making the object are included in the digital file. It would basically be a compiler (like OpenSCAD) but instead of boolean operations it would execute a series of physical operations just like if you were building the thing in real life. All you'd need to do to build the object is read through the "script" the program used to draw a picture of it. Any changes, like raw materials, or different tools, would be easy to track, so forking it for different reasons wouldn't be a problem.

elifarley

It reminds me of the Brian Bishop's SKDB project and Mariano Alvira's project named "CAD".
Are you aware of them?

Jason

Good responses, but I think he's talking about a couple layers up. HDL, CAD, and sharing physical things over a network is more of a protocol or standard which then allows you to implement something. But the bigger question is, how do you know what you need to implement in the first place? How do you know what the basic process is to become self sufficient in your local environment without getting personal verbal or written help from a local person who is already doing it?

How do you track how certain things have been done in the past and how they have progressed over time in your local area? How is that progression recorded? Maybe an advancement made a machine's design faster and more efficient, but if that technology becomes unavailable, then you'll have to backtrack to what was done previously.

What if you have to add certain customizations to a machine to make it work well in you're specific local application, but for 99% of other people this modification just adds cost? How do you ensure that people around you are able to find this information that will quickly get buried because the vast majority doesn't care about it?

What happens if the internet goes down, and these resilient communities can't access their online information? What if OSE's database is shutdown or destroyed and we have to pick up the pieces?

MasonB

Jason is spot on. And he posed the core idea of the questions a lot better than I did.

Elifarley, I did not know about them, they are both very interesting. Like Jason said I am talking about a level up, but projects like those are definitely a step towards what I am talking about.

Matt, those things are definitely steps needed to support a system that I am talking about, the model editor that builds a list of commands was quite an interesting read, as is the way the way you destructured complex problems down to solutions that could use text based formats similar to programming languages, and hence leverage existing technologies like git.

Another thought I would like to add is (And this may be completely off base) it doesn't seem you have everything you may want or need in your list 50 machines, so this system would help reduce the rethinking of design every time someone wants to make a toaster (Or anything else, from mechanical components to bioplastics, from water filters to bread, from staples to pens, from microchip fabrication machines to silicon purification), indeed they could browse every possible thought on how to make a toaster, all of the different versions made, and the reasons they were made that way, and design or choose the toaster that fits their needs, and then fabricate it efficiently. (By efficiently I mean the system could topologically sort components and create a timetable, and then use the calender to reserve time, and the inventory to check out/reserve the tools/materials)

Also, this would allow for better refactoring [A term from programming used to describe redesigning how a program fits together], if sometime in the future somebody dreams up a way to combine two of the machines listed, or a way to pull out a common component (Like with the power cube), it will be easier to see and use the change across the whole spectrum because information could be updated without having to go through every wiki page manually.

My argument for all this is, if you are going to build a self sustaining modern civilization that only relies on local labor, you should make that labor as efficient as possible (especially in process and data management), and those efficiencies should themselves be local. But I also don't think it needs to be a high priority because it probably won't matter until you have at least a couple of OSE based communities, I just wanted to toss out my thoughts on it because it directly related to things I think about all day in a novel way, and sort of consumed my thoughts for a few days (and still does, the more I think about it, the more I want to be part of an OSE based community later in my life).

Also, eight thousand years from now, it would be cool if OSE groups could trace their lineage back to the original version, but that's just cool, not a real reason.

Matt_Maier

One thing to keep in mind is that the people who are good at developing technology are horrible at documenting it. The best approach is to build the tools they use in such a way that documentation is captured automatically. They won't do it on their own, and if they try they'll just produce bad documentation. I don't know if you can ever hope to get consistently good rationales for designs.

Howdy, Stranger!

Categories

In this Discussion

Open Source Ecology Forums