.
FRDCSA | minor codebases | System
Homepage

[Project image]
System

Architecture Diagram: GIF

Jump to: Project Description | Parent Description | Capabilities

Project Description

Within the FRDCSA it is not always apparent where to place custom tools developed for systems. So they can go here.

Capabilities

  • our system should pass all downloaded and visited webpages, probably using a squid proxy, through an analysis system. It can check for things like repo links, formalize the text knowledge using workhorse, etc. etc.
  • A way that we could have the system identify which project information belongs is to sort PDFs according to the projects they belong to, then index text to directories and learn which directories are associated with which text.
  • Develop a system part of audience and erc specifically for saving, organizing and searching transcripts of irc sessions
  • life-planner/index.html">free-life-planner should have a predicate which tracks which predicates and atoms should be released with the system.
  • life-planner/index.html">free-life-planner should have a system to explain its logic to different people. Should be built using Prolog.
  • All packages should have tests that can run after installation, in a standard location, to ensure that the system is working.
  • Using the names of systems and descriptions of those systems, train a system to extract system names. I think this was the system-ie project
  • Try to automatically extract coocurrences of system names to identify relationship strengths between systems.
  • Have a filesystem listening process that listens for new .do and .notes files and automatically adds them to the list of files for our todo system.
  • Replace POSI machine with a 6GB system from Bellwood.
  • Calibrate the FLP planning system on Chess and go.
  • Org-FRDCSA-system-Cyc, exit
  • Write something for when.do that does textual entailment to determine when when conditions could be being satisfied and recommends the follow up. Also develop a menu, for free life planner, that allows you to select the when conditions from a menu, and includes the rte system?
  • Come up with a function that tells us all bills that are coming due, and plans to send them well in advance, knows the latest date it can send them (for instance through the mail or electronically), knows the earliest, etc, has useful knowledge regarding all aspects. Create inventory management of our goods, look into the KnowRob system for examples.
  • Create a system of taking tasks that are placed in the group task queue, so that people can cover different tasks. Create an emergency management team
  • Implement a system for permamently storing certain window configurations, especially documents being read, or if not window configurations, academician documents being visited by Emacs.
  • Implement Audience module in free life planner for connecting to our mail servers and querying whether there are messages presumably sent to us by friends which have not been addressed. The system should simply indicate who has contacted us and how many messages are queued and what their estimated importance is.
  • Add basedirs to action-planner-open-rule-file system.
  • Write system to process honey-do notes from emails.
  • Org-FRDCSA-system-Cyc, quit
  • Create the fcms object affordance system. So for any given object you can have a range of affordances for it and such.
  • Add localization to the life-planner/index.html">free-life-planner system. it's more than just translations for all the names, as there will be cultural differences.
  • Org-FRDCSA-system-Cyc, Deregister
  • Org-FRDCSA-system-Cyc, deregister
  • Write a system to record which Cyc predicates we've learned.
  • Implement a system for recording when we learn different Cyc concepts. Integrate into Clear/academician/Study space.
  • Find a system with better accuracy than my FreeLogicForm, maybe C&C, and apply it to the NL to FOL converter.
  • Have our todo system try to extract meaningful context from our work, so that, for instance, the previous unilang entry I wrote (1509834) doesn't get misinterpretted out of context.
  • Substantially speed up the guardian system. Have it write to a file which is then cat under certain circumstances.
  • Just thought of a system. Knowing all the different things that we use, we can surjectively search the CSO for everything that has to do with important topics. For instance, we could search elpa and melpa for Prolog, etc. And make a ranking over all packages.
  • Broaden architect's related system functionality to have ways that it is related.
  • write a function that uses architect to do a choose from emacs between systems related to the system in the cwd directory
  • If Flora2 can be compiled to YAP, then perhaps we can run FLUX with Flora2 for an additionally peowerful system.
  • Write a programming-by-example system for the situated-agent that learns what we are doing by observing our commands and the buffers we are editting and the cwd and other features.
  • Work out the KBFS system and then backpropagate information from academician to refer to the correct documents in KBFS.
  • Maybe study more about type systems and the like before writing the system/index.html">kmax-object-manipulation-system
  • Individual objects should have timelines that are explorable in their KMax Object Manipulation system interface.
  • Incorporate a GUI for this system in IEM.
  • Start wrapping our system agents in screen sessions.
  • Fix the system for generating DVDs using KBFS
  • The planning system might be able to plan the movement of an item, when we find it in a different place, so that all preconditions and effects are observed. It should for sure plan any movement we make.
  • See about creating auto-SKSI system.
  • Can write our API learning system, feed it with the initial parts of the subl doc that we have, then have it probe and test, to learn the API.
  • Fix system::KNext to list different kinds of output formats depending on whether the Cyc annotation, PrologCYC annotation or no Cyc annotation is used.
  • Fix system::KNext to auto compress all it's output files.
  • Fix with system::KNext the way it seems to be missing so many of the sub-sentential items extracted with KNext in the output on ushell.
  • Add something to system::KNext to incorporate checking if a live rcyc-1.0 or pcyc w/e2c is connected.
  • install gnome-online-miners on a reference debian system.
  • find-or-create an emacs function that allows you to push and pull from the xclip and the system stuff. so I don't have to use the mouse.
  • Have to update the system::Cyc item to use multiple instances of Cyc, and have names to disambiguate them.
  • Add that Job site that Eric mentioned to the js-rapid-response system.
  • Create a system for managing the current work context, and be able to switch between contexts easily.
  • Develop a system for, in addition to the system/index.html">kmax-object-manipulation-system, classical planning for it's use for people who do not yet know the functions.
  • Write a system that records what we browse in cyc-mode w3m browser and such for cyc, to record our history.
  • Get proper error handling with system::KNext, also get it to handle all those errors CLISP was spitting out.
  • Enter all of Michael Iltis' documents and software into the KBFS system, and begin annotating it using nlu and such, in order to derive our representation and also to have the information required. Write a document mentioning all the different layers. Fix the nlu code to work with KBFS. etc.
  • Write a clip system for reading part of a text, by saving a region into a file that is called something like --w3m-clip--.
  • We could integrate the prolog store that Jess is talking about with sayer2, and specifically that compression/representation system.
  • Create a mode system using headset by using double press of middle button as escape or something for clear. Have the ability to change up the reading list, and all kinds of other tasks using the headset's 3 buttons, with double clicks for each of them or something.
  • Set up a system with KBFS using Prolog which understands whether a directory has been updated or not. And reminds us, when doing the kmax-update-frdcsa-repositories to do all the different ones that need updating.
  • Note that the Cyc attempt to model the world as most sane, adult humans perceive it does not account for different perspectives - I had planned a system that would, but I can't remember what it was - maybe it was FormalForum or ReasonBase. It was like Wikipedia although there was no consensus. It is also related to the ConspiracyTheory system, which models, ideally, every conceivable or at least extant conspiracy theory - the idea is to model alternate possibilities with a view to establishing the truth of competing hypotheses. For instance, this evidence backs up that hypothesis.
  • Integrate with normal form the different stuff from the AMZI expert system tutorial.
  • Develop a system for looking at all the possible rules we have, and determining, based on text to logic conversion and also textual entailment recognition, when the rules are satisfied and what the consequences of this are.
  • Develop a system for listing urgent situations and ways to resolve them.
  • Add argument system ability to tag rebuttals from books, and also manually with news reporting.
  • Using the new academcian/clear code for getting pages right, perhaps the system could also strip repetative boilerplate where it exists using code derived from aie.
  • For freekbs2 come up with the ports for programming with it, for instance, failing from cannot prove, failing as negation, etc. Work out programming system with it.
  • Create comment system for news-monitor.
  • Finish the AMZI expert system tutorial.
  • Work on a recommendation system which recommends software for a task. For instance, if you use mbox files, you may wish to consider mboxgrep, although it's just listed as a package, with no way to recommend that to (well perhaps besides the package recommends in the apt database). Use the package recommends and other field to train the recommender system. For starters - make it much more complete - by having more criteria and rules for suggesting packages.
  • Think about EIEIO in relation to KMax Object system
  • Also - as in how our chair has a negative space where the wood is taken out, and we can see images from that negative space, our system should notice things beyond the tokenization framework. "Who's on First" type thing.
  • Also, as in how our chair has a negative space where the wood is taken out, and we can see images from that negative space, our system should notice things beyond the tokenization framework. "Who's on First" type thing.
  • One possible thing to do to get the auto-programmer and the iaec and system-implementor working, would be to have it try out every different possibility of mereological type such as when KNext is saying that something may be a certain way, but it is unclear which way it is. Could also order them by probability, such as by using WSD results. This way, the program can direct it's evolution. Then we can simulate everything from the structure describe by the text, as input to the program for trying to evolve programs to solve problems. Awesome.
  • Here is an idea - let's combine some systems - basically the system that does programming, with an evolutionary algorithm. Have it's programming attempts be used as input to an evolver. That way we combine the generative ability of the auto programmer, with the testing ability of the GA selection, for more directed evolution. The idea is that just randomly mutating functions is not going to result in a good enough performance because of the complexity of functions.
  • For reference-systems, have an index of all the packages on the different systems and their executables, etc, so that we can tell which system can run a command we need.
  • Make the SPSE2 system have a component associated with normal-form which associates tasks to be completed with rewards for completing them - then integrate the normal-form and execution-engine permission systems.
  • Perhaps one way to start is with an Inform7 type interface to the system, and then apply LogicMOO to it.
  • Work on system-implementor, flesh out the code generators.
  • Make sayer not dependent on a DB, not big enough. Have data stored on the file system or something.
  • Get a server just to load ./system-recommender on and keep it loaded. Have it agentified for UniLang and have it execute try catch SQL query statements or something like that in order that we don't have to reload the whole thing whenever we want to execute a function on its data.
  • Find the system that generates the complex query of the datamarts.
  • Integrate nlu with an agent for a system that understands text and can act on it. Have it use rte to see if the text implies certain things, and then input to BDI.
  • For the agent which tries to download software that is referenced in PDFs we read, use a BDI so it doesn't saturate the system.
  • Develop an agent to comb through all of the files on my system and categorize them and place them in an order.
  • Develop font highlighting system for nlu knowledge and other FreeKBS2 knowledge.
  • Add other cities to the js-rapid-response system, but check for telecommut/remote stuff
  • Develop an intelligent tutoring system technique behind FRDCSA.
  • Just now thinking, I wonder how they know that Goedel's definition of a formal mathematical system is semantically complete - in that there is no greater system that does what it does. I'm guessing they use the Church-Turing Thesis. Or they show that PM can already prove enough somehow. But what I'm wondering, is, given that the definition is only sufficient to describe formal systems of that type, whether, by the addition of extra information to the program, such as defeasible reasoning, whether the Goedelian incompleteness (Liar paradox) can be sidestepped the way the Axiom of Extensionality sidesteps Russell's paradox.
  • Have js-rapid-response pay attention to the skills employers are looking for and tie that in with the intelligent tutoring system.
  • For our system which is related to AM eurisko cyc bps, listen to the song a whole new world, and extract all the nouns and adjectives which relate to interestingness, such as "a wonder", "sights" or "fantastic". Have the ai apply such descriptions if it merits it.
  • Have the SPSE2 IEM2 system integrate with the manager system that records task completion, have it note how long it took for a task to get completed, apply machine learning to predict the length of the tasks based on the description and other slots, then analyze existing plans and put an estimated range on the duration in order to help with the planning process.
  • Develop more notes on the system that is designed to prove algorithmic correctness of properly defined problems, and how to express the problems. Also relate to AM and The Unknowable.
  • Need to have the ability to prove that a given algorithm is correct. Store the proofs in the system.
  • Org-FRDCSA-system-Cyc, query
  • Org-FRDCSA-system-Cyc, echo hi
  • Much like install-script-dependencies grabs dependencies, find-or-create a system for auto configuring packages with a ./configure script - in a vagrant VM or such
  • A funny name for a system would be iaec, e.g. "I AM EURISKO CYC" read "I am Eurisko, psyche!"
  • Merge the Eurisko and Cyc documentation I've obtained with the academician system.
  • Develop a tool which we use to record our decision making for different problems. For instance, in trying to determine where to put the new aloysius system, I ruled out a merger with the services.frdcsa.org because that system is currently running on justin, which is insecure. Although, actually, I could move it to workhorse if I could find a way to route it.
  • Integrate into the normal-form system, not only protocols for managing stuff, but also security protocols and the alarm systems.
  • Develop a word sense disambiguation approach for KNext files, so that the actions are tagged with the appropriate senses. Research state of the art - although note - we already have a WSD system enabled - maybe integrate that for starters.
  • Use deep learning for system for doing commands.
  • Integrate brainleach with the system for planning bash and perl scripts, and manipulating linux, and have it understand what's being written, and use that to record scripts, so that when we build a machine with vagrant, and make modifications, it can add those modifications to a bootstrap.sh
  • For js-rapid-response - implement a system for it to act on urls that are provided, and store them, with links to the mentioning article, etc.
  • Add to academician / nlu / system/index.html">argument-system / etc the ability to argue with a text and store the argument.
  • There is a notion of what are all the commands I can run at point, so for instance if certain commands would fail at point, then they would not count. This concept is part of the system/index.html">kmax-object-manipulation-system.
  • Make a js-rapid-response system which hosts the user's resume, cover letter, and email for the company to see, via a password protected site.
  • Write the system/index.html">kmax-object-manipulation-system system - although try to read about EIEIO etc first, type systems, and so on. Read about Category Theory.
  • You can do knowledge acquisition from corpora by asking questions of the data for which the answer is known, using a system like Nutcracker, LogAnswer, or Groundhog, except that you find situations where the answer is present, and you look to see which literals in the logic form were unable to be proven, and add those literals to the knownledge-base - or something close to this.
  • Write a system for using SVM classification on the application history with js-rapid-response to predict which new postings we would apply for, and to submit a text message to us when one becomes available.
  • Develop a new system like the windows search thing.
  • Make a system for following up on lists and recording actual completion percentage or such.
  • Develop the where-is system such that I can record locations of objects after I find them along with descriptions, plus a search tool to look for them.
  • Maybe have clear read our unilang logs to us, selecting which ones are system messages versus ones written in English for us.
  • Do an analysis of what is wrong with the current KBFS system, as to why we need to reengineer it.
  • Using faster mogura Enju system
  • (Maybe you meant system() when you said exec()?)
  • Have a system for multiplexing functions and api to emacs and the cli
  • Add a rule to the system to classify messages that are psychotic references into schizophrenai
  • For system/index.html">kmax-object-manipulation-system, the thing at point, and like for instance, in w3m, a URL under point, should automatically hint at certain actions. For instance, the URL will have different actions possible to undertake on it. Perhaps what we need to do is use EIEIO and duck typing or something.
  • For the system/index.html">kmax-object-manipulation-system, have it so that you can bring up a gloss page which allows navigation across common actions, facts, etc about the object. So for instance if the type of object you selected was a paper as in research paper, you would have affordances for obtaining the citations, etc.
  • Input emacs symbols etc into the context of the Emacs nlu system.
  • Rework the system for nlu etc to use kbfs tags for representing the contents of a buffer. so for instance, it will know the buffers title, etc. these will be properties specific of individual kinds of files, for instance an nnvirtual:article buffer has a summary, store that, etc, in kbfs and associate with the annotations.
  • Consider replacing the internals of Verber's module system with Flora, so it can infer answers etc programmatically.
  • Work with the CIA open source notification software or any of its replacements to make a system for packaging newly released code automatically.
  • The verber system should try to plan for "one day more"
  • Figure out the proper place to put the system for location logic that tracks and acts on things like 'bring the camera when going to the parade'.
  • Have to write tests for the inclusion system for Verber.
  • Get used to the idea that although we want to make a flexible system, I am still going to have to do a ton of programming. What exactly to program is difficult though, because we might get bogged down in a particular system, like Verber - and not have a correct picture of the relation of that particular project to the overall goal. What is needed is to locate and package existing useful systems, write some code, and rerelease a tarball and package.
  • Develop a transactional system that backs up the freekbs2 stack and ring, and allows you to undo
  • Add to nlu a "language" recognition system that can determine if particular regions of text are a given programming language, pseudo code, or what not.
  • Build the sayer/nlu/KBFS system that asserts information about files and explores all the possible things to assert about them.
  • Come up with a system of saying things like something is a research paper, how do we do that
  • Rewrite KBFS to use theorems stated about files, sort of like that one derivative system we made.
  • The same system that is responsible for mapping out our file systems should take over browsing the web to find software we need and incorporate it.
  • Have a system for allowing us to tentatively schedule activities when certain conditions, in particular, predicted weather, obtain. So for instance you can say the first sunny and balmy week in spring, clean out the garage, and it alert you, based on checking the predictions, when this could possibly take place and tentatively schedule it.
  • Note that just now in trying to extract a system with packager it attempted to build a package
  • Come up with a space of observations that can be made about a simple text string, in order that the system can be trained to learn what appear like similar objects - for instance, adding a autoguess option to Choose
  • Get KBFS::Cache to write it's cache when used with system-implementor
  • Have a system for having PerlLib::Collection stored in a KBS2 domain.
  • Make git repositories out of every system's data section to prevent data loss. Back those up.
  • Come up with a system of access control across different FRDCSA servers. Prevent personal data escaping.
  • New years resolutions. Aggregate all resources of the FRDCSA. to.do, .notes, daily todos, unilang logs, etc, into a unified information access system across the FRDCSA, add search abilities
  • Build a recommender system into Action Planner that recommends rules that it thinks you would like to follow.
  • Develop a system of Emacs default contexts for different applications.
  • The system should work with all the knowledge it has about the contents.
  • Write an extension for system-recommender which looks at all the project specific files as purposes and prints out recommended links for each project.
  • Write a system for fun, just to get back in the habit of things.
  • Schedule days or write a system that helps me stay focused on important stuff.
  • Obtain the nlu system TIL2 and Bridge from the paper Textual Inference Logic: Take Two
  • Obtain the SNePS grammar system called snalps
  • Implement an FRDCSA wide search system.
  • Schedule major system work and do it then, such as the backup.
  • Get the page tracking system working for academician.
  • Create a roundtrip system for files, that reads to and from, like the nagios files.
  • Work on an automatic classification system that knows which context an assertion belongs to, similar to UniLang's classification, and prompts to disambiguate.
  • Add time to read to the system based on the temporal planner.
  • When you purchase something that is on the SPSE2 shopping list, have it link to the purchase record and the inventory management system.
  • Get a system for tracking where we download files from.
  • Get a system for requirements analysis.
  • Develop a system for organizing related files in a directory, for extraction in order to package them, etc.
  • Use the planning system to find when we broke discipline.
  • Develop an expense tracking system.
  • Develop a question and answer system.
  • Fix the PSE system.
  • Setup a system for referring to the entry in a to.do or .notes files, but that you can assert things about it. so basically like C-csl.
  • Integrate the paper reading system from academician with clear.
  • Develop an agent based system for conducting research on a topic.
  • We can do all of this and more with this new system.
  • Since action-planner uses an expert system using negation as failure, and GGP GDL is based on datalog which also uses that, see about somehow codifying the rules from CLIPS into GDL and using that to formulate "games" that can be solved out of life rules. GDL has 'legal', see if we can't have something like "recommended".
  • Combine sayer with CSO, to have a system that asserts knowledge about software packages and archive files, etc. That's KBFS, so finish it.
  • Integrate POSI functionality or develop separate POSI system. Change the name.
  • Integrate architect into the fweb2 system.
  • Convert main FRDCSA system to encrypted.
  • With utility-maximization-system, add "is there a cheaper work-around?"
  • Fix the nlu system to put better names on ghosted files because Emacs bookmarks does not see them.
  • js-rapid-response: Implement a system for cleaning up the database, removing all entries that were not viewed, etc.
  • Take the job-search system and have it learn which types of jobs to apply for, have it figure out when I'm not looking at it and only train on examples where it was clear I was reviewing
  • A key feature of our system will be the ability to look ahead to see if there is actually a promising situation ahead, and to plan for that.
  • Make the Free Life Planning Coach system use Facebook for the extraction of facts about a person.
  • Develop a system to backup files.
  • Develop a core operating system that gets all the essential stuff up and running.
  • Develop a system to reason with desires or goals listed in this system.
  • Create a system to browse recently added desires, formalize them.
  • Have a system for ensuring that maintainence goals involving recurrent activities are known and fulfilled, for instance, activities to check RSS feeds and identi.ca
  • Develop a system for controlling expenditure by solving the utility maximization problem of economics.
  • Help Haydee set up her RADAR system for tracking hollywood production information and leads relating to job acquisition.
  • We can take UniLang entries as arguments in a Dung-style argumentation system.
  • A system to help me fulfill my obligations to others.
  • Set up a system for semantic disambiguation of text phrases, to resolve to dbpedia, similar to 'dbpedia spotlight'
  • Test the system with Chinese and Arabic characters to make sure it can handle them.
  • Develop a rule based system that monitors the addition of new assertions and for instance, whenever a new research interest is added, will launch a program to lookup software of that kind and documents about that subject.
  • Set up a backup system that backs up our systems periodically.
  • Develop a system based on affordances which asks what we might want to do with a given document. For instance, the information extraction tool can be used to process html pages. Need a logic to specify this situation.
  • Develop a database backup strategy for my main system, perhaps invest in a hard drive at Fry's.
  • Develop PSE capabilities to interact with the spse system.
  • Fix the UniLang system for getting the ID of a particular assertion.
  • Org-FRDCSA-system-FactualStatementExtractor, exit
  • For the workhorse system: http://www2003.org/cdrom/papers/refereed/p831/p831-dill.html
  • SPSE2, add-goal This is a test of the capabilities of the system.
  • Get the UniLang system active again for recording messages....
  • Create a log system for KBS2.
  • Cyc, (cyclify "My system by Aron Nimzowitsch, first published in 1925, has its place among the two or three all-time most instructive books in the literature of chess.")
  • Formalize2, This is a test of the system.
  • Formalize2, This is a test of the axiomatic system.
  • Create a system to eliminate name collisions.
  • POSI needs FoxTrot recommender system or similar.
  • Create a system for version control of KBS knowledge bases.
  • Run descriptions through folksonomy and put tags on system.
  • RSS aggregator should have a reference system.
  • Use POSI interest system for setting up film making projects.
  • Maybe add an IRC client to the Shared Priority system Editor
  • use this /var/lib/myfrdcsa/codebases/internal/unilang/scripts/convert-perl-to-emacs-data.pl for the freekbs-es system
  • Develop a system for pausing/silencing all TTS agents and music when an incoming phone call arrives.
  • Have the assignment email system email me a copy of all the assignments
  • Integrate email priority system into ball-in-court
  • Develop a documentation hierarchy, in which key explanatory documents are propagated to the right place within the system.
  • Create a system where we can assert that at such and such a time we worked on a task.
  • Have a system which automatically sends out jobs.
    ("comment" "107215" "sends out emails for jobs")
  • Develop a system for Justin to comment on the ethicality of the work.
  • Write a system that calculates whether a given job is financially worth it, ethically worth it, etc.
  • Develop a system that estimates a price for a given task.
  • Help Richard with setting up a task system
    ("comment" "107039" "outlook?")
    ("due-date-for-entry" "107039" "1 weeks")
    ("comment" "107039" "sent him an email with instructions")
  • Develop a system for estimating reliability using Ball-In-Court
    ("pse-has-property" "106983" "important")
    ("pse-has-property" "106983" "complete this")
  • Develop a system that determines whether names are liable to be made fun of.
  • Develop a system to start archiving my inbox, instead of having an imap %inbox folder of 70,000 messages
    ("due-date-for-entry" "106789" "7 days")
  • Formalize the reward system for things like a laptop if I balance my budget.
    ("due-date-for-entry" "106742" "3 days")
  • Make a system that does abductions from text, kind of like that one that we saw on Kinoc's page, so for instance if it said so and so gave birth to a child and we knew that so and so was a human we could abduce she was female.
  • Start investigating potential limitations of the system, and tracking them, in order that we can repair them ahead of time.
  • Setup a spare Koha install system for Mary...
    ("due-date-for-entry" "106595" "3 weeks")
  • Ask Justin and Chris to develop a system of interdependent goals
    ("due-date-for-entry" "106567" "3 days")
    ("assigned-to" "106567" "Justin Coslor")
  • Write a report system for how on task we are based on the manager agenda system.
  • Find a state machine system for doing parsing so we don't have to write them manually.
  • Setup a system for resolving questions by asking them of friends. For instance, will jbalint be at chiglug this weekend?
  • Create a feed whenever we finish a new system.
  • Process my IM logs and add to the system.
  • Write a system that classifies messages as personal or not
  • Write a system that calculates which modules we should document first.
    ("comment" "106146" "use task1 stuff for this")
  • Develop a system that shows us who is interested in collaborating. For instance, Mary Hart would be at this moment.
  • Develop a core operating system which involves things like finding amenable hackers, etc.
  • Make sure we have a system for detecting and managing licenses of various data.
  • Add a capability to know what NOT to say in public for android TTS Manager system.
  • Setup a system for raising awareness and lobbying legistlators, etc.
    ("due-date-for-entry" "106040" "2 weeks")
    ("comment" "106040" "look at the open source government stuff")
  • Write a system that maps words by analyzing keywords in wikipedia documents to develop a model of what words reflect knowledge of what skills.
  • Suggest rewards system for those who complete self-assignments.
  • Develop a system for rapidly contacting senators/etc, based on issues.
  • Get a system of notes for what I need to tell people when I talk to them - have the system automatically infer when I am talking to people like through IM and tell me what to tell them.
  • Write a system that takes logs of what people are doing - like bash transcripts or emacs key stroke logs, and tells them about things that are related to what they are doing but that they may not know about
  • Justin wants a system to prevent people from regressing.
  • Develop an agenda categorization system to categorize the purpose of various tasks, such as personal, work, etc.
    ("due-date-for-entry" "105550" "3 days")
  • Write system that takes care of hard/soft deadlines. uses \C-cpdd versus \CcpdD
    ("due-date-for-entry" "105387" "1 days")
    ("completed" "105387")
  • Contact Porshe from Heritage Prarie about the commercial, POS system.
    ("due-date-for-entry" "105365" "3 days")
  • Write a system for authorization requests... or rather, opinion requests, for PSE tasks.
  • Write tutorial on using the Eolas system.
  • Write a system for determining the due dates of various assigned tasks...
  • Write a system that helps me to think about things that I can do.
  • Figure out a system for handling the Microsoft phone on and off capabilities.
  • Make sure that our messages are being acted on for some automated system.
  • Develop a system for e-mail prioritization.
  • This is a test of the new speech recognition system for Uni long.
  • Hit these people up for assistance with the telephone "agent" system.: http://www.ireport.com/docs/DOC-168967
  • Write a password management for programs system.
  • Add something to the audience irc system to read :) as smiley, etc.
  • Eventually relate donations.cgi to the budget system which tells what goals various purchases will solve.
  • Develop a policy system
  • Develop a budgeting system that makes use of the goal system.
  • The donation system should provide an explanation or justification for each request.
  • Switch the current Manager::Scheduler2 system for monitoring crontab with a inotify or whatever.
  • Write a software system to more or less reconcile the data files for different projects.
  • Create a system so people will know whether I will be at the POSI meeting.
  • Can have a system that determines abnormalities - for instance, say the relation ("belong-to" <system>) was accidentally asserted ("belongs-to" <system> ), this system would detect that.
  • The code mapping system si going to be complex in that there are going to be refactorings. Maybe it would be useful to integrate this into a version tracking system and do autoamtic analysis of code changes.
  • Develop a basic nutrition analysis system that counts complete proteins, etc.
  • Realized how to go about building the scheduling system. Use it to develop itself. In fact, this is generally the way we can solve all problems that are (circular references) eigenvectors. We know that by solving themselves using themselves, we will develop themselves. So for instance, to solve the scheduling problem, we start scheduling the building of the scheduling system.
  • The talking point system could have expansible topics, perhaps using the zooming text interface eventually.
  • Once again, the system caught me sinning when I wouldn't have noticed before. This just proves it is doing well.
  • Work on system that dynamically loads agents when messages are addressed to them.
    ("completed" "94497")
  • Write a system that, using previously visualized data, learns automatically how to generate plots for data based on the data received, and explain moreover the meaning of the plots.
  • Traditionally, which system does backups?
  • Reasonbase can use existing IM logs to find plenty of examples of arguments, and build an audience dialog system based on that.
  • Need the isolation system.
  • Can't wait to have my content extraction system working.
  • Here is an idea - for every requirement, we can guarantee some axiomitization of that requirement for the purposes of planning. It is through that axiomitization that we can improve PSE or whatever that planning system I was working on is called.
  • The various agents should dialog with the user to figure out the nature of their problem and how they might solve it. That is how we will get that help system to work.
  • Try to get that oid system going here.
  • Develop terminology management system that creates giant definition of all terms we are using (Justin's thesauri). I do not need to wait for him to work on that.
  • If get that system working now, I will be well on my way to improving in many regards.
  • So the system rewards the user less and less for increased performance, forcing them to improve even more.
  • Have system for SinLess for retroactively asserting sins.
  • Have a system that sends out our think tank's ideas to industry. Ask them to let us know if they've chosen to adopt our designs.
  • Had a strange dream. Actually kind of nice in some respects. During the dream I was coding software to perform a variety of essential tasks. I was writing one larger system and the way I was writing it was by then taking those modules and combining them. The modules were interesting but not practical and I forget what the program did. An example was that I was building a recognizer for people walking in the woods. I talked with a lady 6 mo pregnant there. I went back to the house and Lauren and Pat Walser were riding their bikes back and forth. They were the age they would have been when I left. I thought "Oh, so not everything is strange, screwed up". <- interesting thought.
  • We need a video4linux web-cam based open source eye-tracking software system.
  • Use Sameer's messaging system (lambda) in order to work with Event system.
  • Develop ammortized internet access needs system.
  • We should develop a system for developing systems. In other words, boss should have high-level design criteria in mind. In other words, let us have a better defined approach to building systems. To build the tdt, we should (after first searching for other systems) collect data, choose a learner, implement the learner, etc.
  • Sinless/Score is a good system.
  • Actually we should eventually factor out the manual code that is making the classifications, and replace it with Manager::Dialog code, so that the whole system is more complex. And, to boot, we should replace Manager::Dialog with Audience, so that everything is smarter. Audience should use theorem proving to determine which context it is operating in.
  • The obvious problem with the meal planner at this stage is that it doesn't have a good inventory management system.
  • Work on the action approval system.
  • Architect can have formal models of solutions, for instance, an "expert system", and can take inventory of the problems (from the database), and can even perhaps match attributes of the problems (in so much as we can model the problem relationships, or as can be extracted from the definition). However, the very indication of the importance of the problem will help to order them for expansion.
  • Move my system to the shelf, so that there is no jostling from the keyboard or desk.
  • Okay, eventually get an assignments system going, so that I can check in with people. Drop them if they do not complete their assignments.
  • Just occurred to me that books etc probably have a noticable context trailing system that Audience could use to measure output.
  • I find that writing a first generation simplistic system gets the basic functionality in place without all the difficulties. It would then be fitting to do an entire rewrite. Boss ought to keep track of that kind of information.
  • Each entry suggests capabilities for our systems. Derive suggestions from entries. Add to capability management system.
  • FWeb should detect archaic system names (like Predator)
  • We need a system of common sense!
  • Start work on the schedule system.
  • Design a trouble ticket system for helpbay or thepathofleastresistance.net
  • Have logistics system to take care of various people driving together.
  • system to come up with names like "One who remasters", remasterer?
  • Have a system for expressions.
  • Write the action approval system right now.
  • Come up with ingenius system for routing messages to appropriate agents.
  • Coincidence Systems - like a vector-space, a system of independent coincidences that mysteriously leads to perfect goodness.
  • Use an inferencing system to determine which features will be available to users based on knowledge.
  • I have to realize that this system is here to help me, not take away my fun. That's how it feels even now just a little while after writing it. It shure is the better system tha that other one.
  • We need a general purpose learning system. Something for we can pass a few parameters and then have online results, or retroclassification, etc.
  • Also have a system that determines when enough time has been spent on one system.
  • I think the reason is because everything had system in it.
  • Create mood monitoring system for mental health, part of Akahige.
  • I kind of like all the emacs things, although, they are not as elegant as they could be. Their functions should form the basis for some future system.
  • Write declassification system that knows contexts and maps those entities to their actual entities in the terminology management system.
  • That last thing works with training materials too. Have CLEAR functionality as one type. Improve that type system.
  • Evangelist can also be used as an intelligent tutoring system
  • Over time, system should try to increase task entropy threshold so that the user must be forced to work on many things at once.
  • By hiring people through our system there is a higher probability of getting good employees.
  • Ask Sameer whether he can think of a better system than a point system for SinLess/Score.
  • Here is what I resolved. Best thing to do right now is work on system for determining where user is.
  • system can guess what tasks you are working on.
  • Actually, we should eventually factor out the manual code that is making the classifications, and replace it with Manager::Dialog code, so that the whole system is more complex. And, to boot, we should replace Manager::Dialog with Audience, so that everything is smarter. Audience should use theorem proving to determine which context it is operating in.
  • That's something that needs to happen, is a system for recording when we get things done.
  • Maybe it is easy to spot nonsense situations like the one above. Add that to time management system via PSE.
  • Justin's priority system would work rather well here.
  • Should define a general purpose classification scheme - so that the system can get really specific about what it just classified.
  • The previous instance of "for instance", as well as this one, are different from the typical usage in their syntax, and this difference is significant. This can help to sort out meanings. Need to sit down one day and thing about that general purpose optimizer system.
  • Just had a rather neat idea for a service to help people with weight/health problems. Like meals on wheels. It is a not for profit, but they don't come every day. You simply order a freezer, (perhaps even a specially designed freezer) and little food capsules containing your favorite gourmet related food are brought and store. Robotic retrieval ensures the proper food at the right time. You use a menu system. The system flatly refuses to serve you bad foods, forcing you to eat better. Does watch what you are eating. Get's you hooked at first with good tasting not necessarily healthy foods. The new idea is a modular food system. The individual packages could be self-refrigerating for whatever reason.
  • When we want specific functionality, the best thing to do would be to do analogical reasoning on existing systems. I.e., find or remember some system that looks/behaves similarly, and just steal that code.
  • Okay, that's something that needs to happen, is a system for recording when we get things done.
  • Okay! Here is a strange coincidence. I was calculating the number of pages that it would take to print out my system, at an estimate of 40000 LOC, and well, the answer was 666.6666666666666.
  • If I observe "the water is getting low" or the system wonders "Is the water getting low?", if yes, initiate a plan to have the water filled within a given time amount.
  • Before releasing akahige, get free exercise information for the personal stretch manager. All systems must be checked for information sources using license management system.
  • Need to have a basic system for prioritizations of tasks.
  • Could have system for summarizing gist of messages.
  • The system should detect superior usage patterns among users and promote them to others.
  • Could build a proxy that lets the user see what documents our system already knows about.
  • For all programs, we can look at abstractions of their functionality, to compute a better way of writing the program in the first place. In other words, for every program P, there exists a system S which executes P in a more intelligent, versatile way. I know that isn't formal, but here is an example. The script that rates the apartments, well, hand writing that is silly because, what if you want to rate something else, you see. The notion of a system that helps you rate things is important. Critic ideally subsumes that...
  • Just a basic system.
  • Create an object oriented requirements system. For instance, we should be able to inspect all requirements that pertain to my chair, such as it having exercise equipment built in and be water/sweat repellant.
  • Justin is having a telepathic test. That's what a subtree is and you can make a super tree by looking at the current configuration state and you can form ontological possibility branches off of each of those decision point possiblilities and that's a and you can make a sub tree by back tracking. and you can do that recursively, super sub super sub and possibility thinking decision tree point network and as long as you use formal system methodology it can be compatible with the map of the current state or with the recontextualization of the map of the current state but since its virtual there's no way to prove consistency and completeness because there's no way to prove those states exist but it can be useful if its compatible with the .. of the current state, cause that at least can give a person possibilities for prioritizing goal structures.
  • Go analysis system is essential for instruction.
  • Could have autocorrection in documents of system names etc using terminology management server. termios should know when various terms were used, for instance Predator. termios should probably also support WSD.
  • It is nice how we tend to write temporary scripts in the scripts dir and then move them into the system when they mature.
  • Have the system judge the complexity of various tasks (can learn this by looking at previous tasks, and estimate in some cases).
  • The problem with the cyc approach is simple, it's not complete and therefore will be too hard. We could go with a more shallow system, that doesn't have full inferencing, but then we lack efficacy.
  • Have Emacs do intelligent programming. Use the editor itself as the system for intelligence.
  • Boss/Architect should support most of those metrics in the Schaums system. Could use PSE for scheduling?
  • The goaling system ought to take care of the types of goals that have tobe constantly accomplished.
  • Should we have some kind of system hatchery
  • Make game theoretic penalty system, so that agents can penalize eachother but have incentive to not overdo it.
  • This system should be invoked any time the user is going to leave.
  • Finish a simple system for tracking what needs to get done. For instance, sanctus has to be working in order to get DSL.
  • In order to prevent DSL abuse, must first get scheduling system running
  • Need to get the language modelling and WSD stuff working well. List it in a description of working technologies that we support (through capabilities management system) . Word Sense Disambiguation. I wonder how to get that working.
  • That indictates that we need to improve the file mapping system, which fortunately doesn't affect the data logging part.
  • Maybe create some system renaming capability for BOSS
  • Note that UniLang should become a system service.
  • Got system convert-script-to-module.pl done
  • Have clear read man pages too. Have a whole priority system.
  • Have a system which asks the user to expand on subtasks of a given system (and try to match these to existing entries)
  • Certain programs should be able to ask questions and then automatically report to sinless the violation, like alarm clock could ask about leaving room in normal form. The actual system should work using inferencing.
  • Keep some minimal system for keeping track of what is important, and actually get it logging time spent on various projects.
  • The system should be more real time in the way it monitors you to make sure you are not falling prey to temptation.
  • Should rate which ideas of most important to get across. Can tie in with the go-analysis system.
  • Integrate Go system into a response generation system for NL, to interactively work with the user.
  • It will indeed be easier to stay focused, now that there is code to prove that we are stayin on task. This system, when expanded some, should assist the user in determining how they are faring for the day.
  • Here are my goals for tomorrow. I would like to get clear doing some basic generation, but I would most like to focus on getting it so I can knock tasks off the task system.
  • When we exit the system, here is what we may expect. We will have to strive very hard towards light and truth. The question of spiritual death, and being able to look away from it, is very important, and we should train ourselves using a standard american athletic training plan to come closer and closer to exiting the system and resisting spiritual death. As you begin to realize the truth, and everything starts to make sense, in your heart where the battle occurs. Therefore, it should be your goal to recognize the onset of realization and to sometimes mitigate its effect, so that too much realization does not happen too fast. That is what is to come.
  • Can use a manual hooks system, so that we don't have to enter every damn thing into the planner, well, I mean, that we don't have to enter things we don't have formaized into the planner.
  • Need to add parts of the system for scheduling common chores, like retroclassification.
  • Event system (which works now) should use PSE pop up for reminders
  • We need some kind of scheduling system and we have to thoroughly test it.
  • Can detect things like this, and during ammortized interaction, develop a strategy for the various ambiguity resolution things. For instance, the previous entry wants to be scheduled, and so a time for it to take place should occur. If the system is able to infer the correct time, then it should.
  • Could have a water meter built into the drink system.
  • Should have a system of helpers where there are local leaders that provide free support to their friends, and they in turn turn to higher supporters.
  • Create a new system for Temporal Constraints.
  • Lessons learned: Step back when debugging nasty systems. If it doesn't look pretyt, try to avoid it. Chances are it's not going to work. Don't do little calculations unless absolutely necessary. This advice should be computable based on measureable proeprties of the programming situation. In other words, if we were to actaully analyze w/ some system, the code being written, we should be able to see whether or not the solution is elegant and warn the user.
  • Relate it if possible to goals. Do not work on the goal system tomorrow, but the day after that.
  • What about events that are too complicated for our system or too rapid, like a crazy with a knife coming at me?
  • Try to Add KSLOC and other productivity metrics to my system so that people can know how productive I'm being.
  • A natural consequence of the intelligence of this system is that it will be easy for anyone to use once working, through dialog management, etc.
  • Create system to kill me and feed me to myself.
  • Use a production system to figure out what I should be doing...
  • Add the task entropy detection to the warning system.
  • People stay with our system
  • Here are some ideas. All we need now is a simplistic goal system, built from the ground up, _maybe_ with some basic common sense. On the other hand, then, we should get the event logging system working, and write helper functions, EventLog, etc, so that other systems can make use and analyze log data easier. We should generalize the functions found in sinless and manager that make use of the score event system, (moving that of course into the eventlog). ProblemSpace should visualize the eventlog data, using nodebrain type filtering. That stuff has to work inferentially.
  • As part of playful intelligence, the system might, in a humorous mode, say things in rhymes like "Very shortly I envision, that coming to fruition"
  • The scheduling system has to learn to deal with backtracking. For instance, if there is a goal to get gate working, and we can't do it without internet access, it has to realize this.
  • The system should also watch for certain actions executing on the computer and automatically notify the computer the next available instance if anything they've done on the computer meets the completion criterion for a task.
  • SVRS should have a system to rate living arrangements, which it uses to help the user form an opinion of various places.
  • We need a system that monitors events and does two things, makes inferences as to what information resources, etc, the user should be aware of in relation to the events, and secondly, anticipates states.
  • Evangelist interfaces with the self-introspecting ai. It uses UniLang etc. It speaks/thinks of itself as the FRDCSA. It uses preconditions for plan generation. It can be used as an its about our stuff. It interfaces with capabilities management system.
  • Ensure that we look at all logs and files eventually. Model which files we have seen when! This ties in perfectly with this log system. That is what it is doing. So from that we may update timing information on all files. Maybe we do want to do an SQL db.
  • Get Todd to work on those parts of the system.
  • The task walk through system should use verbal checks (like "check") to complete tasks, using TTS, etc.
  • Study NLP techniques for this system.
  • I think the best way to get this system up and running is to try to get spark going.
  • Our capabilities management system should be able to help save trouble by remembering for the user the various functionality.
  • Send Justin the RESONANT FREQUENCY OF FORMAL system AND INCREASING RESONANCE BY ADDING SELF-VERIFYING AXIOMS paper.
  • Every capability request should ultimately be assigned to a system or subsystem.
  • Should probably find a more standardized way of talking between UniLang and clients. Protocols are nonsense right now. mike is right - develop a protocol system.
  • Maybe make a neighborhood swap mechanism where people can get things for free from their neighbors (a computer trade system).
  • The planning system should actually send messages over UniLang and all the programming be handled in Perl.
  • There are other things going on: interpretation of Stallman's statement. There are hundreds of programs (things you have to do and run) in a Unix-"LIKE" operating system.
  • Create a hypothesis system based on stochastic inference. I believe that powerloom does that. Could use powerloom.
  • No doubt other programmers are suffering through these exact same problems. Too bad they don't have an intelligent tutoring system to verify familiarity with our methodology. This is litterally a turn-key programming solution.
  • Be sure to write a better system for text navigation in kmax.
  • Generate a system wow - "War on Words" that rewrites the news how it should read.
  • I need a system that answers questions like: which systems are using "verber::Ext::pddl"
  • The priority system should be related both with verber, and...
  • Our planning system (verber) should have BDDs, for conformant planning or the like, and as new things happen, it should just change the current plan to that tree of the BDD so to speak.
  • Need to figure out the unilang name system very quickly.
  • Note that unilang should become a system service.
  • Probably want to convert unilang to a system service pretty soon.
  • Should use a tags system to boot strap the classification of unilang notes.
  • svrs should have a system to rate living arrangements, which it uses to help the user form an opinion of various places.
  • study nlp techniques for this system.
  • study - reading system needs additional rules to reinforce its search.
  • The study system should model motivation for certain solutions, and use that to vector people along.
  • Have system for sinless for retroactively asserting sins.
  • silo - the inventory management system should take a look at hmax.
  • setanta should have a priority system like Stet to bring questions to the attention of the user based on the importance of the question, etc. Used for short term questions.
  • Essentially take the existing setanta system and make it into Luigh, setanta's Charioteer.
  • Write the system for setanta to interpret its messages.
  • sinless/score is a good system.
  • Get a simple system going today that tells me what remains to be done for the day, essentially an offshoot of that score thign.
  • I suppose I can create a basic sanctus system to handle certain features already.
  • savant or whatever the capabilities management system, should come up with a large database of existing capabilities, probably expressed in some language like the PI calculus.
  • Fix radar to support automatic figuring out (testing whether the system is available in various archives (that is not to say that it in't something simply because it is not in the archives.))
  • The pse system should have a mode for recognizing dependencies, and this is where it generates a list of estimated pre and post dependencies for each item, (focusing of course on important items).
  • Event system (which works now) should use pse pop up for reminders
  • Develop Emacs picform system.
  • Have libsystem-conceptnet-perl modules for each system in perllib.
  • mush as name for MUlti Strategy Help system.
  • Therefore expand on the event system for manager.
  • Replace existing manager context system with a more unified, pid file like based system.
  • Develop a self-organizing file system (kbfs).
  • kbfs should operate like LogicMoo, having a MUD like representation of the file system.
  • gourmet should use Opt as its type system for ingredients.
  • The medical type system will be similar to the gourmet food ontology/ type system.
  • The system didn't appear to get most of the work on pgourmet, then again, most of it took place in gourmet.
  • fweb should detect archaic system names (like Predator)
  • Use the template system on fweb to generate better linked documentation.
  • frdcsal FURL can serve as the basis for that web checklist based system, which can use question answering, etc., as FURL is both machine and human executable.
  • T-Rex is instantly applicable to event-system.
  • Use Nodebrain for event-system
  • evangelist can also be used as an intelligent tutoring system
  • Need to have some system that answers questions like: How do I delete redundant emails from my inbox?
  • Difficult to do transaction system in Perl.
  • Can't do any real changes to the system until we have some backups.
  • One of the first things I can do is this: generate a meal plan temporal planning system to handle recipes, with a trial translation system.
  • Using the system architecture information we construct, along with intersystem relations, we can do code generation.
  • For some time now I've wanted a system that will do machine learning on derivative theorems.
  • (write system to browse fravia (seeker itself should do that))
  • do a backup of this system over to the frdcsa.onshore.net
  • Complete that crazy diamond system.
  • Use the critic system on this score stuff as well, in order to come up with multiple taxonomies.
  • This new system is the basis for critic, kbfs (now we have the KB for it), gourmet's ontology, etc, etc, etc.
  • The critic system is almost complete using freekbs, and newly written code currently under score.
  • Should complete a basic schedule system manually, using corpus to look things up.
  • Get a 3d card and create a cool system for clear that uses web cam based eye-tracking and 3d graphs of content areas and images (images could be pulled from documents when appropriate and displayed in the knowledge display.)
  • In order to have searching through what clear has read, set up an information retrieval system.
  • The manager::Records::Session system can zoom to the nearest complete clear screen in order to begin to reconstruct a given location.
  • Maybe create some system renaming capability for boss
  • Add flawfinder to boss, and create a more thorough security system.
  • Generally have a system for mnemonics, seems like that would be part of bard.
  • bard's acronym generation can be funny - Difference Of Opinion Mixture system (DOOMS)
  • audience should work to expose fallacies, in coordination with the Legal reasoning system.
  • audience was already a good system, and now its even better.
  • Possibly use celt as a system for keeping track of things over audience.
  • Would be nice for the systems to know various interfaces, for instance, if audience is asking the user something, then it should necessarily use the expert system for generating interfaces that manipulate data.
  • reasonbase can use existing IM logs to find plenty of examples of arguments, and build an audience dialog system based on that.
  • Just occurred to me that books etc probably have a noticable context trailing system that audience could use to measure output.
  • Use an event system and formally model requests through audience.
  • Develop talking points system (within audience)
  • audience should make more use of the letter authoring system.
  • Use architect to generate systems for as many real wrold uses of our software - for instance - roommate management system, etc.
  • Build a classifier for architect that concerns which software belongs in which system (or maybe in boss)
  • architect the entire study system first - before starting writing any part of it.
  • Tell him roughly what got done - that I stripped all timewasting programs and file dependency against them all, installed critical system.
  • Seems to me that it would not be that hard to adapt the class scheduling system to handle all events.
  • I can replace all instances of Jason Sayne in my system with my name if need be.
  • Need a comprehensive inventory of all good system capabilities.
  • Using the log files which show all the items I've viewed using Sorcerer, we can easily feed this into the system that determines what I have already seen.
  • My idea was this: for the movie, use all the different software like that movie data for infovis-nlp or whatever, from IMDB, to create a recommender system etc for movies for our perusal - then of course the movie systems are used for
  • Windows is the most widely used operating system and all throughout my work history I have used it.
  • Get a system together for storing addresses and stuff of all my friends.
  • The planning system should actually send messages over unilang and all the programming be handled in Perl.
  • In fact, all data must be cleared through the search system.
  • Think holistically of all data sources and how they affect security through the classification system.
  • I've spent all my time today working on the time management system, when I could get it done instantly using something from the internet, but I need to finish the time management system before I regain internet access.
  • E.g. a system that does all of this already?
  • In building the classifier, we could replace the individual system names with thissystem, that way it wouldn't aid in selection at all
  • A clever way to make my system smarter is by using manager::Dialog to record all decisions, per application, in a database.
  • setanta - Write a program and hook it to UPS smtp system to shutdown all non-critical services in the event of a power outage.
  • Where is that system for recording all the perl modules we have installed.
  • Pile up all my questions from this system and send them to maintainers.
  • note that I'm not sure all unilang.xml messages made it into the system.
  • Create mood monitoring system for mental health, part of akahige.
  • If a singular item is entered, look it up and if it is some kind of purchaseable item, or a software system etc, route to appropriate agent.
  • Build a better agent system that allows start and stop.
  • Create a system for penalizing having anything overdue in agenda.
  • Create a points system that doesn't reward missing goals.
  • Create accounts on box and have them setup to use the FRDCSA by default, then people can use the intelligent tutoring system to start mastering the FRDCSA and can also start documenting parts of it, etc.
  • Develop an FRDCSA troubleshooter system, yes, I know, sounds like Windows
  • Add the ability of the system to automatically determine the importance of, and set a due date for, a goal
  • Have the ability to link goals together to be accomplished at the same time. Due this, by having them as predepends for other goals, and set the due date on those goals, and then get the system able to handle that case.
  • Add items for reading the mail, for replying to people that we should reply to, etc, as part of the agenda system tasks.
  • Create a system for saying, let's do this now, and it execute code that helps. E.g. pause for tara starts TTS that says a remembrence for Tara, or plays music during which we pause.
  • Gourmet: Support Materials for Software Developers : Nutrient Standard Menu Planning : Healthy Meals Resource system: http://healthymeals.nal.usda.gov/nal_display/index.php?info_center=14&tax_level=2&tax_subject=234&topic_id=1944&&placement_default=0
  • Create a system for scanning in items to put them on a shopping list.
  • Add a system that uses timex3 and sends a message to unilang-client that says something like "Authorize: 3025823 ("pse-due-date" "235523" "1 month")" for something that says "do this next month".
  • For POSI, perhaps just have the system freekbs-assert ("requestor" 230953 "aindilis") for goal ids
  • Come up with a system of priority contexts, and have the tasks filtered by context.
  • Somehow move the entries in things like todo.el into the system.
  • Create a finance manager system, apart from broker
  • When I have some free time, write a system that spiders Match.com or EHarmony. or whatever, and scrapes the profiles of all the women, then processes them for mistakes and writing level, values, etc, and finally outputs the top listings.
  • Create a distributed file backup system using something like Cleversafe.
  • Use named entity extraction software to extract names from text and correlate for the who is waiting for what system.
    ("completed" "82046")
  • Add a "requestor" model into the PSE system
  • PSE: Have a system that, while not necessarily forcing you to do things, at least has you look at it by a certain time...
  • Have a system that, while not necessarily forcing you to do things, at least has you look at it by a certain time...
  • Have it setup that when I change directory to a project, it shows me the last notes about that system
    ("completed" "81625")
  • Use radar-items.dat to get a list of software websites that can be used to enlarge the dataset for system-ie
  • Build a system that refreshes me on the various capabilities of the FRDCSA.
  • Should we try labelling a set of documents for capabilities and run an information extraction system on it?
  • Create a new system for adding things automatically to the completed pile, by typing them into unilang, i.e. completed: setting up researchcyc
  • A query by document system: http://www.blogscope.net//tools/phrase.jsp
  • Create a system that explains how I solved certain problems.
  • Have a system for predicting when users tend to log on...
    ("comment" "76376" "add this as a modality to LifeNet.")
  • I need to troubleshoot this system more.
  • This is a cool system.
  • Develop a system of fundraising to give to various causes.
  • Develop a system to search a site for a concept. So for instance, I wondered whether they reinstated the service to a particular website in an article. So, in otherwords, do query expansion.
  • Write a system for updating all the FRDCSA git repos on several machines... using Expect and a terminal or something.
  • Create an install system for the FRDCSA...
  • Develop a system for spotting which goals are related. So if I say, I want to do something related to inventory, suggest to them that they work on the inventory control software.
  • Ask Eddie to help package a working text to speech system.
  • Write that system for detecting bad terminology, like 'mp3 player' 'utilize', 'DRM', etc.
  • Develop a system for automatically finding subgoals of an existing goal.
  • Develop an interest recommendation system.
  • Get the letter authoring system working again...
    ("completed" "73572")
  • Fix the irc notification system thing to have the option to not report meaningless activity, or at least report it with different sounds
    ("pse-has-property" "73055" "important")
    ("completed" "73055")
  • Have a system that recommends certain scripts based on watching your input... i.e. if it sees an error saying a perl module is not installed, it recommends the install-script-dependencies.pl program...
  • Create a topology map of the system. A gui written in vxwidgets for making queries in POSI...
  • Have the PSE agenda system determine when things were accomplished on time.
  • Setup - like RMS - a system which says I've got your email and it will be analyzed or some such thing
  • Develop a system for commenting on the ethicality of fields of endeavor
    ("comment" "69334" "and projects.")
  • Create a search system for unilang goals
    ("comment" "68027" "already have corpus -s \"search\", but I think I mean here something like Capability::SentenceSimilarity")
    ("same-as" "68027" "68444")
    ("completed" "68027")
  • Develop an agenda system for Emacs.
  • Expand the freekbs system to do more than just unilang entries.
  • Come up with a system for more intelligently doing queryagent, by adding a sequence number and verifying that in the received message...
    ("pse-has-property" "65307" "important")
  • Develop a system for talking with people to help them, like a girlfriend so to speak.
    ("comment" "64384" "Kind of like a counsellor")
  • Backup the entire al.frdcsa.org system, not just the myfrdcsa part.
  • KBS, MySQL:freekbs:default assert ("comment" "50959" "This system can simply check email histories for response emails that either have a subject line that matches, i.e. Re: Thisorthat, have content that matches, ie. > thisorthat, or are simply from the person.")
  • We need to implement a better system, obviously we instructed something that wiped out all the data we had.
  • Start having a system for locating files, seeing as we have so many.
  • Interrelate all the major goals from the system.
    ("pse-has-property" "62059" "habitual")
  • Backup the system.
  • There are similarities between sayer and the nlp system.
  • Write a system so that we can query databases as though they were freekbs contexts.
    ("unilang-message-classify" "60303" "icodebase-capability-request")
  • Currently our system for quoting arguments to PerlLib::MySQL is insufficient (see QuoteIfNecessary).
  • Currently, our system for quoting arguments to PerlLib::MySQL is insufficient (see QuoteIfNecessary).
  • One advantage of having everything in the inventory management system is that it will be trivial to sell stuff on Ebay.
  • Write a system to submit new tickets to RT.
  • Write a system that monitors IRC channels for subjects of interest based on my writings.
  • Write a system for preventing or at least making more difficult the execution of certain commands until various tasks have been completed
  • Add Textmine QA system support to QUAC.
  • Write an interface from our task system to RT.
  • The Audience system for tracking whehter people have gotten back should do so by a given date, i.e. if so and so has not responded by 2 days, alert me, and/or resend.
  • Write various audience modules for interactiing with different mail systems, like yahoo, and our system.
  • system for making sure we've gotten responses should also check whether we've responded to others. Part of Audience after all.
  • Learner can have a basic system for flagging when something demonstrates it is non-deterministic (by simply observing which functions have output that is different on the same input)
    ("unilang-message-classify" "55600" "icodebase-capability-request")
  • sayer: we can train a system based on existing programming systems.
  • Look into that system for composing topics by Chang at Pitt.
  • Implement the Tarsqi system for anaylzing messages like "Call Justin Tonight".
  • Make system that finds commonalities between people based on their websites.
  • Ensure my system is backed up, gosh darn it!
  • My system will be vulnerable to random data.
  • Come up with a system for storing information on common commands, like scanning an IP range for hosts
  • Create a system for extracting all references to something out of the UniLang logs, etc. For instance in 53757 CW means Computing Workshop.
  • Create a system for linking dependencies together.
    ("depends" "53591" "53588")
  • This system is major Z-land!
  • Write a function for inspecting a pdf file for system links.
  • Have any of you geniuses thought to connect an intelligent tutoring system to a machine learning system?
  • Adapt jlsi for system-recommender
  • Have a system that records whether we are getting responses on emails we send out.
    ("comment" "50959" "This system can simply check email histories for response emails that either have a subject line that matches, i.e. Re: Thisorthat, have content that matches, ie. > thisorthat, or are simply from the person.")
    ("belongs-to" "50959" "audience")
  • Keep a database of the FRDCSA system capabilities.
    ("comment" "50422" "compute this by taking the intersection of completed items and capability request.s")
  • Develop a system of references to common, important, locations
  • Update the FRDCSA emacs preferences system to the proper Debian one.
  • Note how all the time I am popping off to subtasks. Maybe should keep a deliberate stack of problems, so that when I accomplish one, I can easily revert to the thing that it depended on. Should have a system for find-or-creating tasks.
  • Write Perl intelligent tutoring system for Justin.
  • Develop a system to classify files on your desktop and put them in certain places.
  • Make a system which autovivifies things like system::LinkParser but gets rid of them if there are other more pressing systems needing resources.
  • Need to figure out on which system to setup the new Koha.
    ("completed" "44576")
  • Enju, The SRI Language Modeling toolkit by Andreas Stolcke is another good system for building language models, freely available for research purposes.
  • Also combine it with the completed function and you have a system for marking what is completed.
    ("waiting-on" "41143")
    ("completed" "41143")
  • Modify do/coach to handle FreeKBS and then you have a system for computing waiting-on stuff.
  • Try using disciple for certain problems until we get a better system working.
  • The point of the terminology management system is to define compounds.
  • The Corpus system for routing UniLang messages can use the thinker/notes system.
  • Create a free "document management system"
  • The todo system may have a problem if someone is on the computer who is not the intended user.
  • Make a system for refreshing good links especially as they are relevant to context.
  • Have a system that helps one to be more street saavy.
  • Develop file classifier, that is a system that looks at all the files and determines where new ones belong.
  • Should we come up with a system for modules to determine whether a unilang agent of them is running and if so, RPC that, instead of starting up? And or become such an agent?
  • Write a system to estimate whether modules are completed.
  • Develop a faceted fault system for tracking problems with codebases. I guess that's a bug tracker?
  • Make system of documentation for people learning linux without a network connection.
  • Our system should know which systems such as MRC psycholinguistics, are available for which purposes.
  • We can use Galago with the task management system.
  • Galago gives a rough presence information system that we can use for our programs.
  • Write a program to clean a software system of non-free software, for instance, replacing adobe acrobat with xpdf.
  • Start moving some services off that system.
  • Develop a software system that allocates money to the appropriate developers of the software you use.
  • Finish up the auto-debtags system and package it for release.
  • Get radar-queue-system to work differently, instead inserting into freekbs, and then having the system periodically prompt to download these. That task can come up under the task manager frequently
  • Have the system try to figure out who is referred to by names, like "Chris" refers to "Chris Lampkin", etc.
  • Create a system of political action items like RMS.
    ("completed" "28361")
  • Find or create a free tdt system.
  • Now get the learn system working to record all this information.
  • Setup system to read incoming mail.
  • Try to run that training system when we leave, so it finishes.
  • Eliminate CSO problem where certain system name entries have trailing whitespace.
  • This is the ushell system.
  • install library system for IAHC
  • Fix the system to remove the logging of formalize entries.
  • We need a system for recording who I've sent email to and what the state of the various correspondences is. Audience.
  • Create a Boycott Management system
  • Get back to all who emailed me. Find some system of marking email for later reference.
  • Develop system to monitor news sites and "inform" them of news that they are missing.
  • Create a system that tracks various movements.
  • system should expect certain things and complain when they don't happen.
  • Implement a system which gives people useful tips occasionally, such as keep doors closed to save on heat or air.
  • There are similarities in a peer review and vote system to the menu system.
  • Successfully test connecting to UniLang from a remote system.
  • Actually do a rough shod system for now, that only approximates the mapping but does the collaborative filtering.
  • this command hags the system: CSO, -a nag
  • Add IRC conversations to the whole system tracker.
  • Create a system for checking people's current email address because we are not getting messages from everyone.
  • Classify is really a system to detect private information.
  • Replace letter authoring system with something else.
    ("completed" "13699")
  • Write some kind of system that recalls where we've travelled across the web tree and allows us to reseed our searches.
  • Create a system for context sensitive definitions. I guess that's WSD. for instance, what is a "DM". in the context of debian?
  • configuration mangaement: SF(2007100 : recipes - The recipes package is a system of installing and maintaing configuration changes. It picks up where RPM/DEB left off, while integrating seamlessly with the native packaging environment.
  • Create a new system for unilang in which agents are of differing types, or at least a service model.
  • Complete transition from PerlLib::system to PerlLib::API
    ("rejected" "11913")
  • Should back up the system immediately.
  • Interface our problem system with RT
  • Create a system for scheduling user actions. Use manager to contact the user.
  • Make a system for learning emacs key bindings.
  • Add (provide '<system>) to each emacs el file.
  • Figure out what is wrong with me sending mails. Looks like something has corrupted the system significantly.
  • Implement a microtheory type system.
  • Create a system for smoothly connecting and disconnecting and reconnecting clients, as well as for holding name information.
  • It may be useful to have the system run the opencyc formalization thing before every entry?
  • Unilang should have some kind of status system and maybe even a panel applet or something.
  • A simple system for recording severity is to use ! x n exclamation points at the end!!!
  • before fweb is rerun, must recover the information on each system.
  • Create system to estimate the time it takes to complete tasks (ETC) for entries labelled as tasks.
  • Note that once I get a system going, it will probably take off on its own.
  • Should have entire planning system with constraint language.
  • Get spark system.
  • For experience modelling system, if the user says they can program in a given language, they must provide an authenticated copy.
  • use the toast system: http://freshmeat.net/releases/205917/, as it automatically locates and downloads source code, determines how to compile it...
  • The route planning system can use craigslist: http://pittsburgh.craigslist.org/grp/
  • Maybe we nee some functinality that tracks whether it is even possible for a given functionality to be present in some reduced version of the system.
  • # come up with a system for checklists for events, that the checklists
  • The system that indexes data can ask for what systems this data is "related-to", for instance a pdf file of a bus line like 74A.pdf, would be related to busroute, not that it would go there, but just that it is related.
  • Want to work on the event system to keep track of these things.
  • What system should manage internet access planning? PSE?
  • The grammar system should not just correct grammar mistakes, but explain why they are wrong.
  • Need way of making sure laptop doesn't get wwet. Maybe have a waterproof system for it.
  • Have a word play system, one that knows all the rules for word play.
  • Set up a system to automatically write emails, and then approve them before being sent.
  • MindBender - a system for argument composition for quickly and effectively changing people's minds.
  • say When you solve that riddle with a WSD system, tell KidKibbitz.
  • We also need a system that contacts all the programmers to obtain their votes.
  • One system I really want is a system that remembers who did what.
  • Some thoughts on how to run the shelter. Get a bicycle, several spare tires, to run groceries from time to time. Bury all money in rocks or the like, littered in special, out of the way locations. Keep a small system on me to maintain a plan when moving about. Have the bike hidden some distance from the shelter. Have the shelter near a trail for this reason.
  • Find out which classes are prerequisistes of others for class system.
  • For SVRS, In addition to thinks like the user reporting that the trash is full (hence the system planning for them to replace the trash), the system might also infer that the trash is full from other things, like the SVRS smells.
  • KBFS should have a classifier that automatically classifies items, using the classification system I am to write tonight.
  • We could interface the inventory management system with misterhouse
  • Should have a system that integrates results of various mailing lists
  • One way to make myself more effective is this - when I type an instruction, like "get latest knoppix dvd" into UniLang, it is going to route this to the appropriate agent using the agent management system.
  • Need to get someone familiar with experience modelling to develop such a system.
  • The problem with becoming a developer or the like is that I don't have the real-time skills. It would be helpful to have at least two things - a system for composing letters, and secondly, a system for keeping track of conversation states.
  • Need a system to answer questions like, why do I have to put new socks on each day.
  • Create survival vest air conditioning system.
  • The inentory management system could use a forklift to put SVREs in storage. They would only need to be removed every now and then.
  • Some features to add are as follows. CLEAR can propose a list of things that the reader may have read and the user select this. In other words, there is a system for selecting which books, websites articles etc have already been read. There would be ways to determine whether a person was familiar with a particular text simply by observing and testing their knwoledge.
  • I realized that the same system that is holding up both Corpus and rsr is also holding up Gourmet. An ontology editor of sorts.
  • Just thought of an interesting way to get my system to seem emotionful. When it is supposed to be feeling a very specific feeling, it plays a key part of a song that conveys that feeling, perhaps with a facial expression.
  • Obviously any analysis of what keys should be has to take in what keys already are. Could use a "seniority/mutability" dependency system to help reallocate keys.
  • Could use EPILOG type NL understanding to infer events for event system.
  • Will be nice to have a system that does all of this data mining of event data.
  • Could have a system automatically try to come up with these (also based on what have been successful ones, and have people vote on project name. That feedback is essential.)
  • This would be as a means to disambiguate items. For instance - "create capabilities management system" - is this done? Well, when corpus is done, it will be, but how does PSE know that necessarily.
  • Convert Unilang to a system service
  • The system can automatically determine which functions it needs to optimize based on which ones are taking too much time. For instance, if in query planning results in generating busroute tables, and busroute takes a long time to do this, Verber's learning component would then determine that this is taking a long time and automatically add a goal to optimize that.
  • The first system that they tackle, or maybe not, should be the group management software. But first they have to be up to speed on the various reading...
  • It would be neat to integrate the agenda with this system so that people could see what it was that I was actually doing.
  • This system will be useful to demonstrate to parents how productive I really am.
  • We need a system that records and plays back an emacs session.
  • I see things like this in the media: Doctors are well aware that even with free software, no system is really free. Is it worth bothering to correct them?
  • I sense the need for a new system - CLEAR determines whether you have read the appropriate stuff - but have you acted on this knowledge? There is a need for a "project manager" that will help with hands on development of various systems. This ties in nicely with our project since we could use this to get people resume valuable experience as well as build us systems we need.
  • Use job search as a capabilities management system.
  • Job search ought to interview the user, perhaps using an improved templated dialog system from audience, to extract the user's skills. (You see I'm really forgetting the proper role of each of these systems.
  • Write a system for newbies to get help based on the web by guiding their communication/posts/etc.
  • if digilib acts as a peer to peer system, that could have possibilities.
  • Before users use a system, they should probably read through the justifications of all things.
  • Jess is not a free system.
  • If I ever need to - here is a great survival plan. rsr, verber, audience, etc must be functioning. Bury all my important belongings except for necessities - as planned by verber. Then, having maybe one system hopefully a laptop, leave town with enough money and possibly a bike, and move to an area where there should be lots of low paying jobs (walmart, etc.)
  • Get system recording basic stuff. Also - sync with the other system as a backup. Start it up every now and then.
  • Make a collaborative filtering system that will work with the debian popularity data and send it to them.
  • Should have a system that determines whether content is illicit - using keyword stuff (kind of how dans guardian does it), and also maybe for videos or images using software.
  • Should have a system for normalizing commands.
  • In order to test the "recently written text" mechanism coloration component, before the actual system was written I just had it randomly make it redder (rather than determine the actual recency of the text). It resulted in "red splotches" which humorously resemble my tinea versicolor.
  • system needs to come down on people. Destroy.
  • Camping - Dust management system (anything storing outside). Sanitary conditions food poisoning. Medicine - advil antacids. Good personal motorcized, ATV.
  • In order to avoid the trap of meta meta system, predator should detect and handle itself.
  • Need to create a backup pretty soon. Need to check out all of our current backups. Need to create secure system division. Have much work to do.
  • Need a system to maintain an entirely free Java environment - call it Java-trap-something...
  • This is sort of a joke, but its worth mentioning. Could have a revenge-system. A simple to-kill does not suffice to bring an adequate sense of justice to the situation, rather, several metrics are recorded - first logged events are mined and from rsr many properties of the ill-effects of an unjust action are recorded, for instance, the overall qualia of pain experience, the pattern of pain and to what extent did this disable the recipient, etc,etc. From this an the model of the other person an exact formula for revenge is calculated. As Mao Tse Tung would say, slightly excessive force is necessary to right the wrong.
  • We can use the CMU facial coding database as part of a system that teaches autistic people facial recognition skills.
  • The way to handle opencyc is to have clients set a flag called enablelogging. If this is enabled, opencyc will store a copy of their commands, and also keep track of whether they have been saved into the world model or not. If the system reboots before the world model has been saved (completely), any partial saved world model will be trashed and it will know which transcripts haven't been saved into the world model. It will then attempt to save those. Saves should only take place during periods of low activity, i.e. it could be a cron job.
  • When it finds mutexes, it should be able to pose questions to other system modules to determine what is more important.
  • It is funny that it should happen this way - but this complete transportation planning system has been on my mind since my sister died in transit in part due to a communication foul-up when I was 10 years old. I was involved, not responsible, but the question was always begged, what if I was smarter, what if we were smarter, what if.
  • Why didn't boss get Calendar and Calendar.pm for event system when run with updatelinks
  • Need a system for removing messages or at least storing them better.
  • Inventory management/KBFS should make use of a common system to manage instances of important items/data.
  • However now I'm too tired to do this. So I need to do that and other related things, like build a better Critic::Classifier type system for Corpus, tomorrow. But I must also eat tomorrow.
  • I believe I should get something preliminary going for PSE pretty soon - as exported from Corpus, for now. So that we can begin to get an agenda in place. From this agenda, and from the interest mapping system, we can start getting activities going.
  • I want to make sure we get the agenda system done so we can apply it to other people.
  • Using our system - produce a feature that you give it a proprietary system and it tells you the free equivalents.
  • In order to get Verber operational we should begin executing basic actions, not entire plans. For instance it should schedule the laundry, by launching it with verber -w laundry, etc. Also, since we don't have the interactive system, it should have the detached operation mode working - i.e. where it informs you of the steps to do and then return.
  • Features to add to Corpus - need to add system to determine whether a property was manually or automatically selected.
  • The web system should be update constantly so that people find it interesting - it should also include news and we should use software to determine the effectiveness of the news.
  • numerous ideas on the subject: should have classes be a type hierarchy. Maybe build a grpahical tool to interactivcely classify these. Convert these system over to KBFS::Cache, keeping a copy of current method. For each icodebase and common (agentified), add a class. For instance, rather than classifying into a vague category, you could classy directly to "PSE, goal", etc.
  • It strikes me that automap is pretty similar to that propaganda visualization system.
  • rsr can use the Critic::Classifier system to classify its events into habits.
  • Some verber specific items here: we want to write a system that if the current plan has to be aborted - will know what changes have taken place in the world model.
  • We will get Verber's type system from OpenCyc for the time being.
  • For event system, we only need it to generate a domain file, which will be added into the system.
  • Modplan is an important system that we should look into for Verber.
  • Also have to have a new-tracking/commentary system.
  • while not individually, collectively it would be much easier on me to simply read books, rather than spend shit loads of time solving particular problems. In other words - the planning system should almost always ahve me study the work before I do it. Kind of like the educational system.
  • One thing I may work on now is writing a system that represents the next days events and other events and generates a schedule.
  • I bet we could store all personal data on an encrypted loopback file system, which would be part of say, KBFS.
  • For the data classification/scrubbing system we could use glimpse to index the files to be classified, and search for proper names etc, semi-automatically determining whether they are important or not.
  • The system should incorporate multiple forms of evidence to make Judgements. For instance, if the system is instructed that I be waked at 1:00, and it does this but there is no movement detected, etc - the system should notice this. It follows that it could learn rules of what things to expect based on relational data.
  • If I can formally marry the notion of go tactics onto the notion of proof and impression, we have a successful system.
  • Add to SOPs when installing a new system, if we pay for power or someone we care about does, system should be setup for powersaving.
  • Secondly we can use UML tools to design IM/Broker/Shops to be a general purpose system. The IM features should be OO and independent of Shops, which is simply the pricing mechanism, along with Broker. The idea is of inventory/goods Input/Output. I.e. buying and selling are featured more symmetrically within the system. Only later are front ends thrown on the thing.
  • The way to get other people to get stuff done is very easy, simply use my agenda system on them.
  • Need to assemble my digital library. Also, need to put in rating system so that Clear automatically builds the library from what I am reading.
  • CoAuthor's dependency system can be used with Clear in order to build mental models. Clearly, CoAuthor and Clear are very closely related, which is very funny since I didn't even detect that at first. We need to get the CoAuthor system's ability to generate dependencies between written materials working so that - 1 - I can generate a doctrinal hierarchy for people to test proficiency in.
  • I have to design my own bed/monitor system. Moreover, I need to figure out where geeks who build things like this would post there results.
  • Maybe we need an application for wisdom - a system for higher level reasoning and appreciation.
  • Need to have a system which coordinates political action.
  • In order to try out new software, we should have a system which has a rather small number of packages installed, except for common ones used by many. We can actually compute keyplayer,etc of packages using social network software.
  • I suppose as part of the health management system, which determines nutrition, allergies, etc, it could try to avoid these.
  • There are a lot of good programmers out there and if we seek to start a correspondance with them and lead them to the right path on their work, for instance someone who has a background with theorem provers and chess, and that isn't part of the system, we can do well.
  • For adopting new users to our system, we ought to first get them using rsr so that they develop good OPSEC, and then start involving them in more and more major planning steps, all the while verifying their reliability.
  • We can have a system that takes people's belief system, and considers what things they are trying to defend using cut-point analysis. From this, we can then infer their entire belief system and their rational, etc. This can be used as input to predictive technology.
  • Just had a cool idea - come up with a system that you say - I need to go to the paycheck office, and spend from 5-10 minutes, then go to the bank, where I'll probably spend 20, then come home, and it computes all the busroutes for all time possibilities - along with certain safety checks, like even if I'm an hour, I can still come home.
  • Use ergonomic motion planning in order to design the interior of the system. Each interior will come specially adapted to the user's physical profile.
  • Need to add the ability to compress various system resources when not in use.
  • Need to create a document authoring system.
  • Josh seemed to like the unilang system.
  • busroute's system should use the following algorithm - take a time window, and show all routes in that by starting at the beginning time, finding the next route, then setting the time to be 1 minute after that and repeating, until no solutions are found
  • True to my style as an advanced programmer, when I noticed the output for the bus planning system for my scheduled trip was wrong, I began implemented latlong lookup for intersections and missed my bus.
  • Got to stop calling ourselves an army, as per Justin's objections. In general, require system for determining this.
  • Event system should have the functionality for scheduling events and other activities.
  • Should have a system of mnemonics that I use to get concentration up whenever I have some significant free time (> 3 days,for instance).
  • Consider asking Pete to work on a system to help Justin off his habits.
  • Architect is a semi-automatic system, and as such, we can have it interact iwth users to determine goals/needs, etc.
  • Write a system to categorize and index other people's actual code. Maybe there are other ways of determining preconditions - the way all this stuff will improve is if we have people mkaing packages and applying them.
  • Verber may incorporate learning algorithms to learn what options lead to good results, as in the Sparc system.
  • I also dream that a girl in the dream had written a system for translating between two languages. its funny how mathematical the dream was, but basically, it worked by coming up with pairs (,) of rewrite rules that could be applied recursively to any formula. Her math was perfect, and real - the set of translation pairs was D. I understood it well. I was hoping she had something for unconstrained translation.
  • Also, in order to have a secure system, I need a computer that never leaves my person. It should be a wearable, vest based computer.
  • I was thinking maybe mstevens would be interested in a deal where we all sit down, one day out of each week, and simply finish a system. For instance, we could sit down and finish shops.
  • mstevens idea: take this system idea, give you inputs , what I want from output, what kind of process I'm looking at for the system, and it should tell me modules and APIs to use for the system. I need a machine learning system to find the difference between these two different AST. Tell me what things I should look at. Thing I don't know about.
  • Going to write a system for rapid teaching of perl.
  • The When I am working. The reason is that I can't very well implement this stuff. I need to explicity monitor what states I am in. I.e., (on-bed adnrew-dougherty_, and provide a machine learning system for recognizing these states based on sensors, perhaps using Weka, or something similar.
  • We can start with a manual todo list - the shops agenda system. That way, I can put deadlines on certain tasks, also assert preconditions in the planner for these tasks. Cool
  • Perhaps BOSS could serve as a system which had "Integration Experiments", "Demonstrations", or "Milestones", etc.
  • Where did the damn mission system go?
  • Perhaps RSRs event system could also help out Verber.
  • We could make peter "AIF Instructor First Class" if he agrees to compile the AIF documentation and design the rank system.
  • We need to develop a ranking system, and give people ranks. The ranking system itself should be termed classified, and should be based on ordinal hierarchies without being apparent.
  • Use critic to relate different Perl modules to different items in our system.
  • Maybe all I need is a system for purifying rainwater, a camp axe, rope, and I can build the rest. I will probably want a gun to kill wildlife that threatens me. Again, all of these would be good, lightweight items. Go with solar power too, and all I need is a battery, and to be honest, I could even use a system to pump water up to a higher elevation and use that to run a generator. Ram pumps. I could use the water as a transport, by having a canoe. Or I could build a secret underwater system for river transport. That would be better. It could be motorized as well, using an electric battery bank for near silent operation. I could don a wet suit. So really, I need to work on the temperature controlled bodysuit.
  • Perhaps I should port the entire system.
  • I love my planning system.
  • I like the use of needs to drive the system development, as when I forced myself to generate a plan to eat before I ate. It was ironic and indicative that at that time I was too tired and thus didn't eat at all.
  • We should have the system operate on people for instance, mach --build-mental-map "Jana Diesner".
  • If you at the end of the day have the system ask you what missions and assignments succeeded, you are more likely going to be able to remember them than if you just ask the user about that.
  • We need to explicitly code the system that mstevens mentioned about involving people in only a small part of your operation. All of this stuff has to be done as programming operations.
  • Before that works I have to have the discipline to plan out how long everything takes, and to adjust these actions uniformly, basically, a system to maintain lies.
  • Keep in mind, how are we going to teach the system to newbies.
  • Secondly, I need verber to start doing "mission" or "operation" planning. This obviously entails another system.
  • perhaps I could write a system that analyzed my log files for instances of ideas that I'm not supposed to write about. This would be an effective way ! Yes! To curb this. All I need to is write it and add it to UniLang.
  • So that is all she wrote. At the end of the day I have to reassess the moment, and analyze this. I need to incorporate this into a system.
  • This is as good a place as any to work on my stuff. I have to improve my system. Basically, I should divide everything into a list, which I carry around me, consisting of things which I will do and I won't do. And of course watching movies must be against my rules.
  • I have to be sure to integrate this information into the planning system. In other words, no unauthorized actions may take place.
  • This system would also be good for Justin. What if he chose not to follow it? No player. It has to work in phases.
  • Probably the most important thing to do is to always make concessions. For instance, no pornography. I suppose, obviously, one would destroy the critic system if this were this case. I also will have to institute punishments for violating the rules. This means that, frequently enough, I must take the entire survey. I don't know why I feel good right now. I think its mental.
  • I can finish the meal planner and I will need to. I need to get software that tracks my progress, making sure that my system is worked on a certain number of hours each day. I cannot count on anyone helping me. It just doesn't work. Not even to get isolated.
  • Determine an appropriate system to mine causal relations from event data.
  • If I'm clever I can fight so that I only have to work on certain days. Specifically start a new system that plays out the work game this way, and fights for me. Politicing, warring, so that I may work on my projects more. This is really audience.
  • Note that Justin's friend Aaron was interested in the clear system, for reading. This means he can provide us books that we should read, at least for understanding how to go about doing things. As for us, we should always keep multiple levels of books, those that we tell non-members to read, and those that we read ourselves. Perhaps we should invent a language for our own communication.
  • Before releasing a system our copyright info must be on them.
  • If you do something at the request of another person, usually, the system should let that person know that it has been done.
  • Add a feature to Predator that records why the user has abandoned work on a particular system. That is important information - don't want to make the same mistakes when we try again.
  • Write system "attack", submodule of audience, which fights back!
  • Dear Mr. Oberweis, I have always thought that what you did to encourage my chess and others was one of the most significant factors contributing to my success as I perceive of it. I have dedicated a major component of my ai system to Mr. Verber, because it was the game of chess that has contributed so much to my understanding of controlling outcomes for desireable purposes.
  • What do I need to do to accomplish this? The use of Cyc is premature, and it doesn't work. Perhaps I could ask Sameer to get working on this. We also need to create a formal command system, and give out rankings, or perhaps not.
  • That way, we can determine what people will want to do, and get that working. We need a basic system for ensuring this happens. Basically, our goaling system must be done first. Then, we need to ask other people. Then we need to identify mutual goals, and tasks that need doing. In other words, I should simply provide people with the information they need to do certain things. But if I don't provide it correctly, they may not wish to do it at all.
  • Risks with the shelter system. This system has several risks. First, how do we transport to and from it? Maybe it should be near a rail line and I could hop the railroad. I might get caught if ai improves. So, what about this. I suppose this clearly presumes some kind of contact and dependence on the world. Of course it does. The question is where to build so that I don't get caught. I also need defenses against other kinds of problems.
  • Perhaps use Verbers nondeterministic planning system in Predator during the packaging stage.
  • system needs to tell us about what happened to it while we were away. for instance, detected power went off, etc.
  • Need to backup my system soon.
  • I need a system that recognizes when I'm arguing and tells me to stop arguing, this could be done very easily with a program that senses voice stress, perhaps liar liar.
  • In other words, the system will do plan recognition, as well as hide information, from the user, that they don't need to know.
  • Be sure to record dreams by finding system that detects REM sleep and wakes me afterwards, with keyboard nearby and prompts me to record dream.
  • It would be interesting to compare the size of this system with Emacs.
  • It is obvious that I need to become reaquainted with my system.
  • I have written that one system and it is /var/lib/myfrdcsa/codebases/internal/critic/learning-classifier.pl: perl script text executable
  • Also, here is some speculation on questions. I observe that Justin takes up a lot of my time. A lot. So we want to give him more autonomy. My thinking processes are slowly becoming shot. The weight of the world. So I need to come up with a schedule. Also a nagging system. But I don't want to get stuck at Justin's with nothing to do or to watch a movie. I think that I should get in contact with Stallman, and get things lined up that way. Then I should accept a move home as a pretense for leaving. I move home, but I have another job lined up. After I move home, I job search some. Then, when gets ineffective, I move to the new job, with parental approval. Of course, all along, I've had a third job waiting for me to arrive.
  • I haven't felt very good all day. I need to get back to doing some programming. And developing that system that reminds me when to do things.
  • Need system for summarizing latest work on a project (really, just ls -alrt), to avoid death by delay.
  • Fix up busroute system for mike.
  • There may be some kind of business directory system. It's worth looking for such things.
  • Just as knowing the position of enemy troops would be valuable tool, so would an automated surveillance system, like VSAM.
  • I need to back this system up soon.
  • Inferring dependencies for items sent to the planning system.
  • We need a system for automatically inferring dependencies.
  • We may use slashdot as an efficient mechanism for learning what people find useful and interesting - should do mining of its contents - especially its ratings system.
  • What is the system for correlating projects to people?
  • Should set up a system that I dimply describe what area I want to learn and it then assures that I learn that. For instance - I need to learn POD documentation. This could really simply be a planning domain.
  • checkinstall is a system to roll rpm packages from sources
  • I ponder deleting the etnire critic system.
  • I can't really update my real website until work on the licensing system finishes.
  • Need a system that, like lookup-el, etc, we can simply lookup the definition of a symbol. Not a concordance, but sort of like it - disambiguate in which contexts the symbol is known to exist.
  • Therefore, need a system to manage my collaboration efforts.
  • Implement a system to give random behaviour to movements, etc.
  • Simply having the user conduct the search is stupid. The system should conduct the search, explicityly verifying whether each system does or does not implement the desired capbility. For instance, suppose I am looking for a text clustering program. Then, when reviewing software, the system should determine whether or not the system in question is indeed such an instance.
  • event-system should look at GACS
  • The group building system. The group building system is a protocol for groups of people to become large problem solving teams. The protocol is as follows. It is clear that if two people are working on contradicting or inconsistent goals, they are not likely to satisfy them - at best only one of them will be satisfied. Therefore, this algorithm dictates that whenever two groups of people meet, they determine which group will be dominant. The goals of the second group are subordinated and integrated into the goaling system of the first group, but the command structure, in the form of a tree, is retained. In this way, large groups can form that solve many problems. Although the individuals at the lower ends will not (seemingly) benefit as quickly, the fact is that as a group they will be far stronger and will thus achieve more of their goals than if they were not to benefit as a group.
  • Change the radar system to download everything later.
  • This should then scale to a larger system.
  • A system should be implemented to record all my voices.
  • Add a step to Predator to have it load the debian control file for a system before asking "Have you made all your edits?: "
  • I'm confused about how Massimo used c4.5 to categorize messages. Maybe a text classification system would be better?
  • WRite a system for posting all events that other people can get email reminders, and can email it events for other people's perusal.
  • It occurred to me that we could also put something into the planner - like, use inventory management system to populate problem model of planner.
  • Make a system that proves that the content is not video or audio, and make this the freedom of information network. Actually, we need to work on ai - that's the most important item.
  • Start building a system for Al with syncronized HDs, etc.
  • Set up a system to handle all the predictors we set up. A seer. What do you call that? Someone that can foresee events.
  • Commission study of performance issues for event.pm given current unilang system
  • So, some of the things I really need to do are write an "Alarm" system, capable of sending messages at certain preset times, durations, etc. So should write that.
  • We can also use the event system to schedule what we work on. So, for instance, coordinating Verber,PSE and Event, we can create a plan for going to the robotics club to resolder the connections to the laptop.
  • We can also use the event system to specify, abstractly, exact times that various things occur, that are supposed to occur on a schedule.
  • We can use the event system for scheduling many things, like for instance, for determining whether a given place is open at certain hours.
  • letter authoring system doesn't record whether you sent letter or not.
  • Factor out TTS server to be part of manager? Or its own seperate system, and then have it connect to the server. Write standard MAS libraries.
  • Make system backups and distribute these many places.
    ("completed" "781")
  • If my recommender system works as well on recipes as it does on pornography I think we're all in for a treat.
  • We need to set up a system for regression testing.
  • The request - can I go to a bathroom, should be translated to a query, and then a plan to do so should be searched for. In addition, various other considerations might apply. Also, a dialog manager should be used to elicit these requests properly. For instance, if I say, "can I go to the bathroom", and the system says "no", and I say "why", this should be programmed so as to give a justification.
  • It just now occurs to me that advogato has this whole project system which I'm sure adds additional important information to the DYnetml files!
  • "isa groupware system and isa debian package" not this silly syntax of coures
  • Need to sit down and figure out our priorities for now. Mainly, I imagine this to be getting the classes system done. I can always work on Gourmet - too bad about Peter.
  • It will be nice to go ahead and get this system operational so that Justin can have some good reading. Should assemble a bunch of nice texts for the lad - not ones that focus on survival so much - since he's inclined to abuse that - but one's that aim to build intellectual stamina - he should rate them! He has a fast enough computer to do voice recognition. Seth should provide us with the "Justin Coslor is the master of the universe stuff". To get programming I will work on manager and "fun" stuff as to focus only on gourmet is a mistake - since I dally.
  • Cannot expect the system to grow by itself immediately, but we can have me providing answers to questions it can't answer, and then the system grows in that way.
  • I need to implement that stuff where - when I am continuously editting buffers within certain dirs it records this as time spent on the project. Besides its obvious that there will be too much stress until I implement the audience stuff system. On the otherhand, how I can I work if I haven't eaten. The solution therefore, is to run, to increase my endurance and my ability to work. This system, BTW, can be applied to also monitor recreational reading.
    ("completed" "303")
  • Want to know whether a given system has already been archived (that is what we call it when the system packages)
  • (http://www.ling.gu.se/~peb/dme-demo/code/ godis dialog system in perl https://sourceforge.net/project/showfiles.php?group_id=123104&package_id=134454&release_id=283493 https://sourceforge.net/projects/nite/)
  • We could have a system for looking up terms based on their definitions: what is the word for learning in your sleep?
    ("comment" "87" "hypnogognic suggestion?")
  • (http://www.ling.gu.se/~peb/dme-demo/code/ godis dialog system in perl https://sourceforge.net/project/showfiles.php?group_id=123104&package_id=134454&release_id=283493 https://sourceforge.net/projects/nite/)
  • (system can estimate the complexity/difficulty of packaging a given codebase, and therefore, plot path of least resistance.)
    ("belongs-to" "37" "packager")
  • (Meet with Christos about data mining system.)
  • Note that all this capability will be destroyed in a little time when school resumes. To counter this, we must have everything planned out for this. We must create a new project, if we haven't already, that manages communication with my boss and also finish the event-system with course auditing information for John Parker, Peter Walker, and so on. Not to mention, that we should really get OpenCyc operational so we can start logging things semantically, like who works on what. New project Paper Authoring system.
    ("critic-unilang-classification" "10" "personal")
  • Forgot to mention need to work on classification system and KBFS using those new perl mods.
  • There is no rebuttal necessary, just look at this system.
  • system to automatically manage all options for all of FRDCSA to standardize them.
  • Should write a selecting agent library that gives the system the ability to bidirectionally communicate as well as to select between user and UniLang messages.
  • To improve timing, for instance, if the system is sending multiple message in between, add a timeout to select in unilang.
  • The problem here seems to be the construction of that system which logs these things.
  • Create a standard question answering system, which not only logs Q/A, builds automatic faqs, sends logs else where.
  • prepare items for Peter Walker to work on making presentations and materials for the Gourmet system.
  • My system can thus generate cluster maps of software systems, or based on subsumption heirarchy, with many links.
  • As there are many sources of new articles, it makes sense that a review agent, that selects which articles are relevant, based on user information as well as predictive information, etc, would be quite useful. The system could read to the user and then load the site if the user finds it interesting.
  • How about a system to randomly refamiliarize me with parts of the system I am sort of neglecting.
  • Create a general system for the following: have an idea of what you are looking, or what would be interesting. For instance, a roster of the yankees is not interesting, a database of students at CMU is. Therefore, the system has some model of what it finds interesting, and then, when searching, attempts to figure out what it is looking at, and correlates this to its interest model.
  • I don't know what it is, but my thinking is screwed up. I forget how important my system is. It's no longer understandable to me. Not really, but in effect. So I really need to work on this stuff more and more. Luckily I get a few days to work on it.
  • rough system to look back through the unilang logs for features, etc, to be called during development phases. high level prognosis of phases should be executed by boss via a manager module.
  • I think I can ask mike Stevens about high quality microphones. In addition to an OCR server, we ought to have a multispeaker speech recognition system that we can use to recongitize contents/speakers of all conversations. As a CMU student, I should have access to this. And it occurred to me that mstevens has access to my system, so naturally, he would attempt to gather as much interesting stuff about it as possible. Therefore, I ought to leave it unplugged by default. I also don't have a way to see if it is transfering any files, and he could have transfered some.
  • We should have everyone register their projects with me, but as the project secretary, I make the major choices on the system design, out of necessity. So its sort of authoritarian when it comes to this FRDCSA end of the project, but naturally this is only one view of the commune system.
  • classified has to have a certain feature: (version control), but yes, here it is, we want to be able to manage all locations of certain bits of information, with infinity/unknown being the unbounded thing. For instance, consider a bank account, you want to be able to know where all copies of your bank account information are, right? And then, if this system gets compromised, it should not however reveal this to anyone, therefore the system ought to be classified personal secret or something.
  • Get the system online, and automatically rotate passwords every week or so.
  • Lastly, unilang must not record empty lines, and frdcsa-el must provide a key combination for loading its page. In fact more generally there should be a system for loading relevant pages in a time effective manner. And I should write a cyclify function that cyclify's the last work, sentence, region, at point etc.
  • Two features need to be added. The first is to #$Clairvoyance so that it can cash URL and read webpages to the user, monitoring of courese what the user has been reading. The seond system that needs to be worked on is that #$Broker ought to be able to look on the classified adds in newsgroups etc, for instance, "shops, soundcard", should return the cheapest sound card infomration.
  • For each open source or otherwise system out there, we must make a specific effort to compare its functionality with our systems having simliar functionality, and determine which is better over all, and which features each is lacking compared to the other, etc.
  • Rewrite my interactive classification system and apply it to categorizing my writings into particular projects.
  • When the user is writing documents, making decisions, etc, the system has to reason about what sort of mental state the user is in.
  • Look into system for reasoning about recurring times - mainly for building/parking hours, classes, etc.
  • My system now appears corpse like - as though there is a body but no life!
  • We are going to want the interactive tutor to use the same dialog-manager as verber, so clearly the dialog-manager is a separate system, it is probably filed under manager.
  • Therefore it makes sense to declare a new system, tentatively called Import or Them or related-projects.
  • Make sure that project summaries are well done and targeted to the proper audience, therefore, have internal documents detailing more technical points but also important communicative descriptions on projects that are targeted towards readers of certain audiences. (Note that everyone says "work in progress"). Note that for predator we could mention that in addition to a semi-automated packaging system, it is a packaging system which aims to capture packaging knowledge from the user. And this is true, that we can augment our own knowledge by observing what the user is doing. We should use NPDDL for predator, among other things.
  • Some of the things that we want to do: get Rolf to fix the opencyc daemonization problem - as this will make RADAR's KB system practical. We can always interoperate between CYC and other ontology systems I would imagine.
  • I really need a system like "Project Navigator", which answers questions like (cyc-query '(#$OrganizationOfProject ?P #$ISI) #$RADARMt)
  • My main priority should be to get a system together for logging how much time I am spending on all of this stuff put together. Especially work. I think I should write my buffer management system. (It won't be out there, so I should get it done ASAP. If only the camera worked.
  • Need to write a system that pulls in ls
  • Should add to clairvoyance readlist items such as my writings, the better ones too. Should "grade" my writings, or come up with some kind of system for determining how useful these are.
  • KBFS: Should be a generalized system for looking up directories containing stuff and putting these on the command line.
  • Map out the space of emacs key binding, write a system that tries to figure out what bindings to give functions. Use well defined memnonics, and info theory, usage statistics, etc.
  • Need to finish the rsr system, integrate with ajd/eventlog system, as this makes sense. In fact, even KEDS and Tabari could be applied there.
  • Some of the things I am thinking about. It will be nice when we have the gourmet system done. It will then simply be a matter of heading to my selected food location at the proper time, preparing my food with minimal effort, and eating. Then rating. In order to get Gourmet done, we have to schedule a meeting for gourmet in which we sit down and do most of the planning. This depends on the meeting scheduler. Perhaps there is such software that we could use.
  • We need an expert system for the construction of systems. Let me explain. Let's think about how to do the following task: sort incoming gtk-gnutella files into various topical entries. In retrospect, its stupid to make such a classification. Luckily for me, I will be taking lots of classes and hopefully I can rid myself of this stupidity. Back to the point though. The system should be able to elicit some kind of understanding of the task to be done and to automatically do such a task. Of course, this simply means the construction of a large system which can do these things, but the important point is the rapidity with which it develops interfaces for a task.
  • http://www.dwheeler.com/oss_fs_eval.html - looks useful for the capabilities management system.
  • Shops could use the recommender system.
  • And we are a collaborative filtering recommending system, etc....
  • need to develop confidentiality based information classification system
  • need to have a system for racial classification.
  • As part of our system we should estimate the sustainability of various systems.]
  • I suppose it is natural that software systems develop command based - because those who have to develop the system are typically people who are command based, that is, they are telling the system what to do. Whereas, if users developed the system (which they can't), the system would do everything for them.
  • here is something, we could have the system automatically watch what the user is doing, and using default rules like "if you are using wget, use curl instead", we can get the user to improve. In order words, interactions with the system should be actively monitored and critiqued.
  • What am I thinking? The MyFRDCSA system is best done as an ontology! All this time, I have struggled to make Cyc work for this, when really, I just needed Protege, or Kaon. Se la vie!
  • The SHOPS purchasing system should have the ability to basically do this: find these items, have them approved by this person, have them billed to this account and have them shipped to this location. Report any anamologies.
  • Tell them that I have been working on an open source nutrition management system, but that these games are very cool since they program the user to do these things automatically, which will speed up and make more usable my software since they won't have to check everything. Neither will they have to study which of course no one will do.
  • Example of how Seth sometimes does not understand things is that he said of our project management peer information system that it was "friends", the relation is not the same.
  • a system. And so, as Al has pointed out it will be difficult for him.
  • Need a system for declassifying documents (files, etc). All documents should be assumed classified until they are proven otherwise. When a document changes, the portions which remain the same are either ignored or mentioned, but the user probably does not have to re-review them, unless of course certain things apply.
  • It just occurred to me that it would be possible to make our system keep track of which packages were built and added to itself, sort of as a recursive log thing.
  • This is (close to) the system I was talking about for making arguments formal: http://kmi.open.ac.uk/projects/scholonto/index.html
  • should have some sort of expert system system administrator that manages our system.
  • One important thing is a system which determines to what extent a user knows a given system, and uses this to improve their understanding over time. For instance, I had not seen: chmod -Rc g+rX,o+rX . before, did not know such syntax was valid.
  • We could have a system where experts from the field comment on the relative merits between software: say between mnm and minorthird, and automatically bias is eliminated.
  • Kickstart is for installing a system, not software.
  • As sameer whether he could think of a clever name for my system, given its purpose.
  • We need the planning system to be sure to tell us how to set up the system for meetings, for instance, if a meeting is scheduled, the system must ensure that it is working first, etc, and get the users to verify this.
  • add travelling salesmen GIS system to the distributed meeting system, and interact with flight system, if necessary.
  • When our system is done, hire a bunch of people to go over it and fix it in a reasonable schedule to be secure, etc. Then hype it beyond extreme, and get it launched into the Debian community - and elsewhere.
  • Here is the game plan which defeated their logic. The theory goes that, upon being reintroduced to my system, and upon finally following through with its designs, I will understand my approach once again. The notion is that I can't see my approach for the reasons mentioned before. I suppose the fallacy I am engaging in is thinking that its my fault that I don't know the ways to do things, when, in reality, no one has.
  • Let us bootstrap the project understanding system by first, isolating ourselves and reading about software engineering, and then secondly, isolating ourselves and writing the core software.
  • This is probably also a good way to get me to setup a system, like the classification system. This is probably especially a good way to write software, since otherwise, I will simply play the game of jumping from dependency to dependency.
  • Watch all pages I go to and index them as part of the system, require online classification, say for instance, when I arrive at the page, launch a popup, which asks me to classify it, or perhaps, when I hit a globally bound key.
  • Add system that fills out forms.
  • system for cleaning directories that are not being used, that are just vacant extractions.
  • What we really need is a comprehensive system to model all people, all projects, all universities as one giant database. No doubt, I would imagine, and hope, that they have acheived this, and that those beaurocratic funding decisions are not made ad hoc as has been suggested.
  • I have an idea now for a useful system. The system monitors social networks, and tries to find ways to persuade large networks of people of some points. For instance, if we want to overtly convert people to become FRDCSA members, it does extensive social network analysis and learning/simulation in order to send messages/etc that obtain the given objective. Or it can try its hand at recruiting covert resources. (Modelling of weaknesses/etc will be an important goal. Notice that the detection of helplessless is important.) Obviously - this is a HARD problem in many senses, but what we will do is gather a system together that does situational awareness - a kind of social intelligence flight simulator, and then begin improving its learning and interaction capabilities - all to the point where a precise, data-driven model of other people can be obtained.
  • Want to implement a system to keep track of regression. Especially with lack of diet.
  • There is obviously a need for an event management system "Andy is reading this file. Andy is eating. Andy is going to the bathroom."
  • For every package that we add to the system, we might as well add certain reasons that we have for having it. For instance, with the Greenstone Digital Library, we can say that we plan to test whether it will serve as our digital library, for organizing our writings, etc.
  • Make a software ontology and start populating it with instances. For instance, "Digital library system", "Graphical Plan Editor", etc.
  • Use LSI-replacement, or automated essay scoring system in order to rate documents in our library for content.
  • Make a website which poses questions, and allows people to answer them. For instance, What is a good system that acts like a personal wayback machine?
  • Compute error probabilities for every phase of the RADAR-Predator system.
  • Looking at what was actually programmed with Manager, I became sort of distraught. It seemed as though nothing existed, and yet I recall doing all sorts of thought about it. What I suppose I didn't realize immediately is that there is still a huge specification embedded within my system. My exposure to outside forces has delayed my understanding of the system a little. And thus, t seemed to me to not be very imporatnt. It couldn't be further rom the truth.
  • Make a type system over capabilities - have inference as to which capabilities are sufficient, etc, for other capabilities
  • That will be quite nice already when we get the system down to that kind of resolution - that it can read a book and then immediately implement the advice of the book.
  • Hilariously enough, my classification system gave /spider.pl http://www.frdcsa.org/frdcsa/internal/index.html an 88% change of being a project, plus 11% of being other, whereas it gave the external projects a solid 100% chance. This demonstrates that automatic techniques are useful in determining the content of pages. Therefore, we should use them to improve the quality of our writing, you know, things like LSA, etc.
  • If we add these statements in UniLang, like the ones above, where we dictate some requirement, we should have it automatically reformat into an imperative form and, as has been noted, add it to the capabilities management system MyFRDCSA.
  • Another thing is that if a program depends on a non-free program, then any petitions to have the program released should be added to the petition for the non-free program. Perhaps we can have it automatically send the petition everytime a certain number of petitioners is reached, or after a given delay. We should show Stallman this and get his feedback. Also, the system should judge the effectiveness and the social politeness of our system.
  • Really have to get a system which documents our fixes, since I keep having to repeat my fixes!!!!
  • Because people make predictable mistakes, part of the its system should focus on correcting those mistakes.
  • Need an active data deletion system: the goal is to minimize the data being taken up.
  • Should solve the storage problem by creating entireprize grade storage: for instance, run a distributed file system and simply add servers as necessary.
  • I don't follow Kevin's logic. He says that everyone is motivated by self-interest, as proof he offers that we are parts of a physical system. Now, I asked him about the mind body distinction, and I said I didn't consider it proven since the mind may not be part of the body nor a physical object. He used a logical fallacy that if something is later discovered, then these are simply new physics. He ignores that perhaps there are objects which can never be physically described, and sort of bastardizes the meaning of physics. But we won't fight him here, we'll simply attack his implicit assumption that this new physics is consistent with the second law of thermodynamics. In other words, I think Kevin has studied thermodynamics before he studied logic.
  • Maybe write a program that can be used for recruiting. Should work on getting the system up that asks people what they want to work on, by showing them what we need.
  • Could add support to the program for calculating, minimax style, scores for conversation. Also, we would want to be sure to add support for calculating the suboptimality of the opponent. Another thing is that, as the conversation gets larger, the search space increases. Are we to fill out the entire thing. Should we do "language modelling"? How does this work? Not very well I presume. Another thing we can do is add an agenda to the system, with talking points that are specific to each thing, with various relationships between the discourse objects.
  • Another thing is that, no one gets access to my thoughts files, but we describe the system we want designed, they do so, and then we integrate it.
  • I liken it to the following situation. Imagine you have a chess master, who is sitting at the board, pondering which move to play. In looking at all possibilities, not directly but through the theorems about chess he has deduced, he realizes that none of the moves are worth making. He stops playing and starts thinking about what the correct move is, what the correct actions to take are. After a very long time thinking, he shouts "Eureka!" He has just solved an important question of mathematical logic and must now begin work implementing the solution. A general procedure for deduction. Naively telling other people, they get trapped in various lines of reasoning which will not result in the system. Amazingly, he must go it alone, but due to the correctness, he must. He found it, no one showed it to him, he figured it out, and it implies certain actions, which he takes, independent of peer pressure.
  • The dynamic generation of user interfaces based on the content of the tasks, much in the same way as content management systems have removed the stylistic considerations from content, will be extraordinarily important for our system.
  • Some things to work on are dialog state managers. Also should have the manager system working soon, although I feel so something, its not a good feeling.
  • system to estimate heritage based on name
  • So I just realized that in some sense, audience/machiavelli is a CMS: content management system. That's what it does, although I suspect it gives more intelligence than is common with those systems. Of course it does.
  • Question, I have a bunch of recipes and everyone has their own way of listing ingrediants. I want to normalize these ingrediants to items from the SR16 database. I have imported this database into MySQL. I don't want to write my own normalization system, although I have a design using some Perl modules that will work. It seems to me that this must be possible using standard tools.
  • Could have a DHTML trellis like system for our system for formal argumentation forums.
  • Our system for capabilities management should work with user who is looking for certain capabilities and compare/contrast/critique/recommend etc, software, full knowing the limitations, etc, of the software.
  • I used a meu system t o acess the capabilities of my mind.
  • We want our system to be "highly developed". Perhaps we should audit catch phrases in a system and use these to highlight our system.
  • When I woke just now, I walked over to the kitchen. The light was on, the freezer door was ajar, and everything had melted. In the bathroom, the water in the toilet was running, and the faucet was dripping. Are these problems inevitable? At least until our system is done.
  • We should have a system whose job it is to profile people for relevance to the jobs we need. For instance, could say Toddmf is smart but isn't interested in doing anything, etc.
  • ideas: use profiles of related software systems to estimate the complexity involved in writing a new system. example: use nut to calculate complexity for gourmet.
  • Make a speech recording system lie at my side while I sleep so I can just talk to tell it important ideas, thus avoiding the difficulty of typing and the misses that result from being too tired to get up to type (or that this would interrupt things.
  • The planning scheduling execution system now seems quite related to Capabilities management.
  • Must specify exactly how we intend to use the classification system. Does it interface to UniLang directly? Or perhaps Machiavelli. What about performance issues.
  • Although, when we get the system working, we should also have it cause us to study quite frequently.
  • Should use Verber to handle conflict resolution. But furthermore, should experiment with Verber in limited conditions. Verber should for starters be based off of OpenCyc, since it is our most expressive system.
  • I should get a new system up and running, do something about being saturated by possibly useful information (perhaps simply record in and put it aside.) Suffer from FSM problems.
  • Sit down sometime and formalize all concepts for the system. Refer to work on formalizing enterprise concepts by Austin Tate.
  • It is exactly mans belief system which makes him a mere object, a pawn in the larger design.
  • We can have predator create a makefile that makes the project then runs a program when it is done to restart predator tasks on the system, such as failure or success analysis, etc.
  • system should calculate to determine what other people are going to do, for instance, like fatso with the air conditioners.
  • We can have a system which prompts the user to approve a choice and also prevents its evidence, but eventually learns which ones it is competent on and which ones are important enough to prompt, and eliminates others.
  • should write a simulator for our system that pretends that it has certain capabilities, but generates rubbish instead, then fix those things that are wrong.
  • try to imagine limitations etc to effectiveness that may affect other people/ calculate wrt estimated historical data, to produce constraints on the capabilities of the global intelligence system.
  • should have some sort of system which indicates which particular functionality is temporary and destined to be replaced
  • our online formal argumentation system is related to seas
  • Thoughts on studying. Open systems theory. How does it know what I am looking at? I suppose it could make note of all programs I use, etc. But in general, here we run into what I am guessing is an open system problem. We don't want to disturb the user but we want to know what he is working on.
  • open source intrusion detection system
  • intrusion detection system
  • Get an electricity meter so we can see the differences, etc, by various systems. Start building a battery system.
  • critic has some of the beginnings of a source recommendation system, and a reputation management system. social knowledge is critical to advancing our cause.
  • have a system which trains the user to use opencyc
  • maybe make our system have ai headlines so people tune in to them
  • should add emacs shortcuts for commonly used things to the respective system, for instance, a shortcut for make clean, etc.
  • Am interested in making a distributed trust management system for knowledge. So for instance, one gets their knowledge from different sources. They audit their sources. The program computes whether to trust the audited trail of information, to determine whether it has been tampered with and which sources are reliable, which specific information is credible, etc. The information contains assertions which are asserted by the party to be true. So for instance, we want a system that does not allow an industry to corrupt our gourmet systems knowledge of diet. So, their are two ways to do this. The first is that health information is entered into the gourmet system from research studies and sources are cited. And the second way is that gourmet actually learns for itself what specific diets are good for what people.
  • we could certainly get some play out of a system like the MyFRDCSA which is publicly editable, with reputation management as well as allowing others to verify given statements (possibly but not likely expressed formally). I.e. someone says that such and such codebase provides the following features, and others can verify this, etc.
  • we can compute special graphs from the system planning system in order to make presentations
  • It occurs to me that the automatic vocabulary builder system can use multiple occurances of a word, the context of the word, and whether it is simply garbled syntax or misspellings, to identify new words and to automatically extract their definitions.
  • Add complex dieting information to the system. Cameron says that a user has to have to discipline to eat well. I.e. to know when they are full. So, we should aim to find a way to help teach that discipline.
  • So some of the things that we might add to our system are the ability to track the trustworthiness of various developers and sites, based on their previous capabilities. For instance, we really want to ask a host of questions: what is this persons past record of packages. How well are they kept? How long do bugs last against this person... Etc. What misinformation does he have. Who does he work for. Etc.
  • we can go a head and create a package which files conflicts with software we don't want on our system, and then file a dependency on this from the FRDCSA
  • make a system called sphynx 3 that handles something related to machiavelli that the police might use
  • need to come upw ith a generic system to reestablis commundations if we tet separated
  • The system works, the system works.
  • capabilities analysis: we could have a system which tries to determine which problems we can currently solve and which we can't. It would use built up libraries of solved problems with multiformatted descriptions, which declare dependencies on each other. Then, when a user asks a question, it does a search of what it thinks may be similar questions.
  • After reading a lot of mathematics, I am getting interested in resuming the study of it, although, how well could we progress without our system? Not well I'm afraid. Although some of the concepts introduced may help with sharpening of the mind, since people tend to dull it.
  • Figure out the command that allows you to reset the whole screen in Emacs and add this to some new system like a FAQ. Check whether there is a nice enough CLI and perl interface (i.e. simple enough) to rtfm, and if so, enable this as the standard.
  • the same system that applies to going home and fixing all their problems also applies to developers of open source software. we can systematically index project groups like our own and begin servicing them with help, basically solving all of their outstanding software problems.
  • Traditionally, planning systems are all about finding ways to solve the combinatoric problem of satisfying a few goals. Why these goals are selected is not usually of any consequence. What we really need is a system that understands what happens if, for instance, you do not pay your rent. Another thing, is that it make sure that the daily average of some required thing exceeds what it needs to be, hence ensuring that you don't fall behind. So, our system is for instance able to reason as to what consequences will happen if certain actions are taken or forsaken, and on the basis of this, determine what it thinks are important goals.
  • basically critic is like a knowledge base editor with some machine learning features to suggest knowledge by analogy that may be useful, and basically to help the user alter the state of relations pertaining to a particular system.
  • My work with the critic system has made me extremely bitter. I keep trying to fix nonsense bugs, but the system is too unwieldy. I'll think its something and modulate this back and forth, trying all possibilities, until it becomes obvious that the problem is somewhere else. This is a lesson, mainly, that we will have to break tasks down into more manageable chucks and verify them. Divide and conquer. The ideal way to do this therefore involves listing tasks, decomposing them, and verifying the completion of each subtask manually. Inductively, so that when the system is run, we methodically check all possibilities until we have eliminated them. I.e. we must be able to prove correctness of plans, etc. But in order to even implement this ability, we will have to apply these rules manually until we have some systems to do this. This means interactively building up a system from small, but verified components.
  • one thing that would be useful: how to specify a failure condition. for instance, we need to get the airconditioners, now, any date set is arbitrary, what we really mean is that we need them before it gets warm. Since we know it will get warm soon, when we don't know, we imagine that we need them ASAP. So how do you quantify this need? How do you judge it? In a perfect system, it would determine belief in when it would be cold, and factor this against belief in how disruptive a particular amount of heat would be. But how do you quantify that? Well first, we can say that if it gets hot one day, then we have failed, to a certain degree. While we cannot specify the amount of damage and hence cost, would we estimate it? What we should perhaps set is "circuit breakers", or warnings that we have reached a particular class of problem. For instance, environmental stability has been breached.
  • Perhaps, as part of the system it should attempt to make it possible to completely and reliably finish a given goal by the said time period.
  • Perhaps, as part of the system it should attempt to make it possible
  • Just start writing the system, and worry about efficiency, etc, later. But, you should certainly keep track of your axioms and definitions of the system.
  • should get a minimal shops system written and deployed very soon. it just logs sales, with a nice GUI, and prints receipts, etc. Should only do basic things, be very forgiving, and then we should scan in their entire inventory. get this all planned out. deploy it on a given day.
  • some criticism of the critic system. It is working better now, but it still has problems with its ratings, as in they are not accurate. must fix problems with negative ratings, and no ratings. could add the ability to use previous durations to calculate new expected duration and set a timer watcher.
  • back everything up to the other system using amanda.
  • should make a unilang system service, and package it so that it operates, all testing can operate on another test network with a different code
  • implement Sameer's "confirmation" system as part of brainstorm
  • critic of planner: looks nice, but as usual, these systems are based less and less on data and more and more on approximations. I think our system is necessary to provide the data driven aspects of planning.
  • A question we're going to want to ask is necessary/frequently used or the like is a given requirement, i.e. how essential is it? This is important because we want to write things that are repeatedly used. Therefore, we almost want to write out pseudo algorithms instead of simple dependencies. So, for instance, we could simply write a placeholder function and then other parts of the pseudocode specifications could calculate which functions are more necessary to the overall development and implementation of the system. We also have to make that distinction between a piece of code being necessary to link to another system, and code simply being used in the process of writing the other code.
  • still need a better system for interactively analyzing relationships (critic)
  • come up with contingency plans for major disasters using our planning system
  • send email to all metasites that we make packages for telling them about our system, and encouraging them to add links. as well, we could ask them politely to try to encourage people having non-free software to release it free.
  • should add features to our system such as the ability to connect and disconnect, and to reply with references to original messages.
  • can simply have the system ask us to approve new systems
  • A user can say, email Debian, and then the system goes about refining a description of the task, until it is executable. This is called mixed initiative planning.
  • while it makes sense to write a make system, these systems are obviously open and hence we cannot expect that everyone will be using the same system. we can realisticly expect, however, that the majority of systems follow a few, not so diverse rules for building and making their systems. Thus it follows that making a universal packager is actually a straightforward goal. And it is a positively reinforcing one, since as it makes more packages it increases the likelihood that the existing systems are already packaged, which reduces the difficulty of packaging.
  • Food processing will be done with the Gourmet system.
  • proposed-system "personal health monitor", a system to continuous monitor a person's health.
  • well, lets give a go ahead for the system and just have it sort all of these anyway, and then see what we can do with them.
  • I'm making shops be an asynchronous system suitable for GUI programming, for example, using Event.pm
  • the essential aspect of nlu for Cyc is verifying that the senses of the terms in the NL are the same ones as those in the KB, so there has to be the ability to verify that sense. Mapping wordnet or similar senses to to Cyc then would be a good start at literal translation, as any NL system which can map to wordnet, sensus or omega targets could then be translated to Cyc. There is a sensus to cyc translation I believe, that would be a start.
  • mayaviz, which is an expert system for visualization and GUI construction, could indicate a direction that we would want to take our data structures libary, that is, associated visualization knowledge for data structures.
  • could use recorded screen shots or video, etc, to help a person categorize what they were working on, in order to aid recall in segmenting time according to what the user was doing. Also, probably a simple keyboard recording, or system activity should be able to do this automatically. Of course it should, you know.
  • We could even have the entire system generated automatically for a given person based on what we think they know. Or more to the point, generate(TargetPerson => ?PERSONA), should automatically state things knowing that others could be watching, and management of secure information lines should be done automatically.
  • We have to thoroughly explore the issue of how to maintain facts. For instance, suppose we decide to change the project name. This should effect all sorts of hooks, includings one which state opposing reasons, such as the project name is already clearly established, etc. Then the system should be able to reason out the issue and then come up with a solution.
  • I'm sure I've said these things before, but they are worth repeating. We should organize a group of people who look at the open source, public domain alternatives for a given capability, and then, working together with the authors of other systems and interested individuals, we come up with a system planning alternative, and outline a timetable for the project's overall development. Then we code like made and release the given software, with one person remaining as the maintainer of the project, and then after testing occurs we get the system loaded into the debian archive, and so on and so forth.
  • should include rationalizations for using Debian, Emacs, Perl, etc on frdcsa-website:. perhaps using our system for rationalized discussion (SFRD?)
  • tell Al that part of the thinking in writing my system first is by the time that I run into doing SHOPS, I will have experimented and tried out several methods of OO Programming. SHOPS is a much more serious system than any of the ones I have written, although it can use them for its development I am sure.
  • Things remaining for Gourmet: Finish XML generation code, clean it up. Find-or-create database standardization system, add to recipe managment. Find-or-create a queryable (XML|RDF) database to store recipeml files and provide utilities for searching. Write interface to SR16, as well as other modules and databases for nutrition calculation. Find-or-create solution to the nutrition management problem. Interface to PSE to generate meal plans. Find-or-create reinforcement learning to model users tastes. Interface to Manager to know when to review a meal. Look into open system for interactively managing food planning by providing a food preparation library.
  • one thing we can do is write a system to find synonyms using wordnet for acronym generation. For instance, if we needed a word that meant culinary but started with a U.
  • We should look into what kind of features such a system should have.
  • one could visualize the communication of the system, and that could provide useful information, especially if cross referenced with automatically generated architectural diagrams
  • we should write a research grant proposal that explains about the current disorganized state of software location tools, and the FRDCSA model, covering the process of locating software with radar, packaging it with predator, and how this all ideally fits in with the Debian system.
  • get clairvoyance system working and associating files with projects, etc.
  • When we incorporate the event based system, we can use its built in priority system to help with UniLang.
  • should implement a system for language proficiency estimates.
  • two ideas, one we should make a system for equitable distribution of household chores, and secondly, we could program our laptops to act stupid if stolen and try to locate themselves by tricking the user into revealing his information, and then send packets, etc, with information about who stole it. We could then present this to the police who could retrieve it.
  • we should have the system calculate the cost of a misdiagnosis
  • well, obviously since my system says it is 4:42, but unilang says its 4:07, somethings screwy there.
  • Stress management should be part of Manager. In fact, the tasks a particular system is designed to fulfull could be implemented as an HTN.
  • it looks as though the early dialog management system will rely somewhat on critic.
  • temporarily make a backup system using the 160GB drive, and that system that's just sitting there. It seems to have RAM>
  • reindex our existing DVD's CD's and then reload the entire system.
  • tell Al that my basic expectation is that as the system get's in place, it will educate persons with what it thinks are effective computing strategies
  • in all instances of any sort of assumption, such as the assumption of a file name, etc, eventually, there ought to either exist the original external justification/specification in the system, or a well-defined meaning of our own given to it, but no decision ought to be left unjustified.
  • should probably put the dvd burner in this system, and burn dvd backups.
  • draw system architectural diagrams and put on source web pages
  • should use interface diagrams that should how each system works, like the big projects do, to convey the principles of the system, and put these on the project web page
  • -the unilang system could be applied to chess for instance, and then the user simply sets various goals during the game, and has these goals solved.
  • write a translation system that "remedies" the deficiencies of each and every symptom of Asperger's (Schizophrenia), etc.
  • should keep a central database of the FSF's position wrt different systems, and use our inferencing system to establish everything as valid, and backed up emirically.
  • implement a system to search for kif ontologies
  • should do work on a general purpose game playing system. simulate social situations, etc.
  • maybe make autopackager an expert system
  • as part of our packager, we can also do an automatic rating system which analyzes the extent to which one can expect to have the given software perform a useful function, and also as it stands wrt our goals.
  • in reading the online logs, I find that the arguments are quite silly, and mostly resort to name calling. What would be useful for an online system is our system that identifies logical fallicies in arguments, and would also force arguments to be formal. To do so would require large libraries, but this is not impossible. So that, an idea can be refuted intelligently, instead of just bickering.
  • don't continue trying to get one system done as you have before, now, divide your time among varied projects to make it easier to achieve things.
  • SAGE designed an expert system that automatically designs visualizations and user interfaces based on the characteristics of data, user sketches, graphical examples, and user preferences.
  • ask Sameer if there was anything he could think of to improve debian's packaging system.
  • since our system can reason about installation procedures, it would be simplistic to make it reason about other systems as well. Hence it is very similar to alien.
  • Tell Al the main problems so far are we don't have gourmet done and inventory management done, so we can solve the food problem. We are tempted to use an off the shelf system, but they never do what you want.
  • also could add that test into the system, cpan_file
  • really the way the system works, I would imagine is sort of like how we are setting it up, basically, a core group of knowledgeable people who can foresee the consequences of certain design choices, and who have the benefit of the experience and the supporting infrastructure and technology. Everybody else simply works as desired.
  • the organization of everything should be handle by a system, and it is but a simple manner to generate all or parts of the site dynamically from the current organization.
  • need to define the layout of the MYFRDCSA system properly, and provide an API for accessing it.
  • The FRDCSA thesis holds that given the amazing range of software that now exists, there is an enormous opportunity cost associated with beginning a project before checking whether equivalent or related functionality exists. In order to do this requires integration of existing systems. A subthesis holds that given the amazing range of free software and open source software, that we can rapidly integrate these systems by only writing a small set of tools, designed to be subsequently modularly replaced as we find the real technologies. The aim of these tools is to package software for Debian GNU/Linux, since this system has very good distribution of software.
  • It should be on a per user basis and be based on cognitive models of the users key performance. Typing tutors are a good example of the most basic kind of tutoring system.
  • Justin is right that we can graph our conceptualization files. Really, we ought visualize knowledge somewhat frequently. For instance, Cyc would make a neat system to visualize. Get that 3d guy on it.
  • expand the RADAR Criteria system to interface somehow with Critic, I would imagine they are somehow related.
  • Critic will be dangerous and difficult to write. Maybe make it into an emacs system, or write an abstraction. Is critic really necessary for PSE? I don't think so. Really, just move the frdcsa-perl shit into RADAR, install those PSE mods, read their manuals and be done with it. Then you can hanker down on PSE again!
  • in asking people to help us, we should find out what their interests are, using a chat program or the like, or even an interactive graph system, and then use this information as part of brainstorm and in general capabilities managers. we ought to also work on getting a common vocabulary going as soon as possible, in order to standardize concepts such as capability.
  • In the limit, we ought to consider the viability of a given system actually satisfying those goals by propagating constraints. I ought to thus read more about constraint satisfaction as a field and also to look into their software systems.
  • dselect should be a related work system to critic
  • our terminology management system should simply scan the Clairvoyance flux information, including the whole documents, and not just what our eyes see.
  • the notion of critic applies to clairvoyance and its notion of tracking what a user has seen, as well as KBFS, and also relates to the general properties of exploration, for instance, in searching for documentation about a particular capability. what is the name of the capabilities management system? cando?
  • use new techniques to finish the critic system
  • run substitute "radar install perl" on that list to obtain all objects installed on our system
  • dpkg-iasearch could be used as a background related-work system for critic
  • should write it so that I just file a bug, and it takes care of filing it with the desired bug system.
  • as part of the legalities of this system, we should make policy that various packages are sought to conform with.
  • email peter jansen with questions about the gourmet system: what do you think of this information, can you suggest anything related to making this better, health information, using KB to plan health, legality of product barcode?
  • add classification system to KBFS
  • it also follows that from this system we can impliment an aware system for performing network tasks
  • unified medical language system for doctor
  • debootstrap should be used for apt-sources to create the base system. check into relation to pbuilder
  • bacula for backing up our system
  • auto-apt should be used to allow dynamic selection of frdcsa system capabilities
  • need to come up with a more useful computing dictionary, that knows "source" and its synonyms. This could be done, one would imagine, by training a system to recognize synonyms, and then running it on open text. how does one distinguish typos, etc? well, you could verify across many sources, and also determine if it used in a different way. good ideas.
  • Basic plan for now is to use the SHOPS system to finish the telnet communication part of UniLang. Then go about trying to get modules installed on our system and reading that manuals for packages that apply to what we are doing. Then go ahead and try to get that part of the system done that sends messages back and forth from PSE.
  • The manager systems functions as a goal planning system for persons, much like PSE, only that the goals involve satisfying certain properties like getting enough rest, getting a good meal --- haha, we can integrate gourmet and manager here.
  • This leads further to another idea for autopackage. That is, when autopackage wants to do something, like install binaries in /usr/sbin/, or do certain scripts, it must be authorized to make these changes. In this way, autopackage can implement security features, by validating potential installs against software that recognizes exploits, like that recently controversial system I read about on slashdot a few days ago. I.e., lots of possibilities here in terms of organizing installs. And furthermore!, we can run debs through autopackage to determine how they check out wrt security..
  • As a unique feature, RADAR can automatically find systems related to a given system, by searching along several properties. One important concept is that a search is not thorough if it does not sometimes check further into things. For instance, to determine in what ways Amanda differs, i.e. what is the difference in its capabilities, it would have to be downloaded, as well as documents regarding it.
  • basically, the stuff that they use is like a whole other system, like "metawindows". Except everything works AIfully.
  • Work should also finish on a system to create daily backups of the FRDCSA.
  • And then I can use an interactive classifier, perhaps modify doit, to create a corpus of actionable items, and then begin a system to automatically translate these into Cyc planning operations, and interact with Cyc.
  • Hi Al, here is my thinking. Obviously we could write a system for Ebay that would help get a couple bucks. This would work as follows. We simply log what is selling on Ebay, descriptions of the items. Then, we also write tools to scan existing surplus loads. We create believed matches and profit estimates, that can be hand reviewed by a person, which then can be used to estimate whether we should schedule an action to by the stuff using our money.
  • unilang should be replaced by a standard system. check out information on dialog management systems to see why.
  • work on the unilang system has been temporarily abandoned. all concentration going to simply designing algorithms for PSE.
  • use a proxy to record why I visit web pages, and use gaze estimation to record what I look at, and then feed this information into the strategist, with a dialog system asking questions.
  • every time you find a software system online, record the strategy you used to find it.
  • could be a good system to invoke regular users on
  • this can be done by writing a small graphical system and having triggers for execution items that cause the display to change
  • should develop a graphical display language that shows the progress, the major concepts, as they happen. basically a graphical log of the central coherence of the system
  • Here is the most complex encryption system possible. Use the ai to calculate a function which reveals the data. I.e. use the complex operations of the ai. That is much stronger than a simplistic time complexityhack like prime number encyrpin.
  • That way I can entrust various people to store parts of the system for me.
  • Get overweight people interested in Gourmet, as well as get nutritionists. Find a nutritionist and ask them to help formalize knowledge. Perhaps use the Shaken system.
  • There should be some sort of system, part of KBFS, Pack, and FRDCSA-dist, that create FRDCSA recover disks, and that these then, testing on what FRDCSA disks are at hand, create plans for reconstituting as much of the system as possible. Also, should look at coding theory for ways to disemminate the data into secure hands anonymously, for instance, steganographically. Perhaps that is why there are so many versions of movies out there.
  • Basically, no planning system whose procedures are stored in files are really acceptable, because it is not convention to edit files like that automatically. What is needed is a DBMS.
  • Coordinate with the developers of existing web nutrition systems to create a sophisticated and integrated open source nutrition management system.
  • for now simply use atd and crontab, make an frdcsa crontab, to schedule system things, like daily updating sources for apt-sources
  • An essential strategy for achieving projects is to reduce the complexity of the task. For instance, rather than require that we first collect all existing log/todo/thoughts files for analysis, we can simply run it on our existing files. Or for instance, rather than copy all of the old frdcsa files to the new machine, we introduces a whole slew of new problems, we can simply resort to a simplified UniLang system that doesn't depend on OAA, get the todo set up, and then begin calculating what order will accomplish things most effectively.
  • I should try to assemble a system which acts as a knowledgeable open source developer.
  • The system should be able to learn over time the algorithmic performance of the user, as well as how to expand on that performance, and should be able to rewrite or simplify programs to run correctly given the mental model of the user.
  • The intelligent tutoring system could easily be adopted to teach not just facts, but also algorithms.
  • as part of the capabilities management system, sometimes we will find a product that does exactly what we want. We should be able to use the products data sheets to describe our specification. Also, we ought to model this formally, as in (productProvidesCapabilities ?ProductName ?Capabilities).
  • Create a system which uses sensors to determine where people are and issue instructions for them for collision avoidance.
  • We could simply give certain people bluetooth earpieces and then they would be set. This would communicate with their computer which would communicate with the central ai system to retrieve instant answers.
  • Write a system for rotating the video files of something like GSPY.
  • Should try to implement a basic system that is capable of downloading all programs in a given search, and put these in FRDCSA, correctly recognized.
    ("completed" "96455")
  • Digest is related to the surjective file system search, but this is relative I believe to current goals, and thus the problem of deciding what is relavent is not solvable given limited knowledge. How do we ensure that if we have seen something, and later have a need for it, we are able to retrieve it?
  • I can imagine a system where you have actions, which have prerequisites, which are tests, which are composed of either code or other actions. Then when you have a goal, there are a set of actions which achieve that goal. In this way you can have reusable plan libraries.
  • Adopt radar to superior configuration system.
  • Interface the Clairvoyance system for ratings with RADAR.
  • Give RADAR the ability to list its modes, and create a system whereby we can simply add new modes as modules.
  • With the Clairvoyance system, track what data the user has seen in an effort to determine, based on empirically tested psychological models, what the user might be interested in or should study. I.E. create a toolkit for such interactions.
  • Create a lintian style system for tracking software features to boss.
  • The Boss project should have a Matrix of what standards various projects have implemented, such as whether their documentation meets certain criteria. This should help to ensure system wide conformance to Software Engineering principles: a sort of Lintian for FRDCSA sources, which ought to be considered to have a specific format anyhow.
  • An example of the good design of this system is that we could easily record when we acquired stuff, because we would have asked for it through this anyway.
  • Hey, Al is right, as the internet is going to make some big inroads int o shopping. Especially if you set up your owwn shopping system, or is this redundant?
  • After installing the SHOPS system, you the next step is to begin scanning When an item sells, .
  • There are several imporatntc considerations in seeting up SHOPS to run your store. The first is to Teh first consideration is installation of the computer system runing SHPS . If your To do this, you need to insert the CD into a system. WARNING: YOU WILL LOSE ALL DATA ON THE system. SHOPS REFORMATS YOUR SSTEM. Only use a PC thatyou don't need any more data an.
  • Welcome the to the SHOPS Point of Sale system. This manual will explain how to use SHOPS This manual will walk you through making your store run off of the SHOPS system.
  • One of our members is an astrologer, and he did a reading on the truck, and found that he objected to us objecting the truck. Due to the peculiar nature of our legislative system, he was able to veto the resolution put forth for accepting the truth. Therefore, I am afraid that,a ccording to the fgunction ing of our organization, I am prohibited from accepting the truck. Our legistlative system uses an eviential reasoning system that is able to combine belief systems in a way that handles mathematical properties of this process in athe least objectionabole fashion/
  • build simple containment system for computers
  • Message to Al, progress is forthcoming. system is doing well. Want Al to consider contacting and recruiting Kevin Reeves for a startup company -do not mention my name, or no?
  • Use system to cite logical fallicies in arguments, like ad hominem abusive
  • So, here are the stages. You have a NL to KQML translation system. This includes a refinement dialog, which can also be used in other settings. Among the targets are relations valid in the planning domain. More later.
  • I must say, that I wrote a letter today about becoming an interrogator, all of this when I could have been programming this PSE system. This is obviously a problem and again, we must patiently, correctively bear through such mistakes. In general, writing should be avoided, programming should be encouraged. This ought to go in manager.
  • That gunsot detection system also could be useful.
  • Apparently a useful system would be to send mail using accountnames that contain the names of the framed mailer, and then include contents. S o for instnace we could send mail as sameersundresh@hotmail.com to someone who nknew sameer, and then use it to pretend that we were him and use this, from time to time, like gandalf did to confuse the trolls.
  • Write a template system that allows you to send mail to people to acquire software from them, for instance, as request at http://www-2.cs.cmu.edu/afs/cs/project/theo-4/text-learning/www/corpusbuilder/
  • Need to have a system that goes through files and determines whether they are safe for publication.
  • God I love this system.
  • The school system somehow rejected me.
  • The difference between this system and an ordinary one is that it helps to significantly bootstrap the process of formalization using advanced ai techniques.
  • Also, I think maybe we can sort of treat this as a kind of system where the functions are stored in a database and can be edited.
  • I think there should be a system to bootstrap the knowledge formalization technique.
  • Probably for starters, we should simply figure out the system for PSE.
  • I dreamt about a neat way to run this system, although it was difficult for me to understand exactly how it worked, although it was in some sense simple.


This page is part of the FWeb package.
Last updated Sat Oct 26 16:47:37 EDT 2019 .