FRDCSA | internal codebases | UniLang

[Project image]

Architecture Diagram: GIF
Code: GitHub

Jump to: Project Description | Parent Description | Capabilities

Project Description

UniLang is a system for providing the services you would expect from a Multi-Agent System (MAS), and more. It allows IPC between different Agents connecting through sockets, and also has packages which client Agents can use to do most of the work, based on Event.pm.

From a users perspective, the UniLang-Client Agent allows us to communicate with a wide variety of agents through a single text based client, from inside the provided Emacs major-mode called ushell.

Ushell now incorporates a bidirectional interface between Emacs and UniLang, allowing us to greatly enhance integration between Emacs and all other systems. For instance, the long awaited Emacs Agenda system was completed with just one function - a call to PSE from within Emacs through UniLang.

Automatic classification of commands is working (see corpus). Therefore, one can simply write what they are thinking and UniLang will dispatch this to the proper agent.

Here is an example of automatically classified commands. Note that the classifier, which usually works well, is not giving accurate classifications for some as simple but unknown reason.

The classifications are not correct, but, whatever.
	[icodebase-capability-request, capability-radar, capability-unilang, solution-to-extant-problem, goal]

I think we should have some kind of autoformatting for UniLang.
	[capability-manager, unilang-specific-message, observation, shopping-list-item, complex-statement]

Great - corpus is working well, if a bit slow.
	[shopping-list-item, complex-statement, capability-manager, unilang-specific-message, observation]

Now all we have to do is fix that data and worry about complexity/efficiency issues with Corpus doing autoclassification.  We also have to add more elegant classification than bayes, as well as talking amongst agents to support better categorization and command execution from our notes.
	[shopping-list-item, complex-statement]

I wonder how much memory this takes up.
	[icodebase-capability-request, goal, solution-to-extant-problem, capability-radar, capability-unilang]

Maybe there's a way to save classifications models so the whole thing need not be reloaded.
	[complex-statement, icodebase-capability-request, capability-radar, capability-unilang, solution-to-extant-problem]

UniLang agents should, defined through Audience, have a nominal state that allows UniLang while dynamically starting them upon messages received for them (so they don't all have to start at once), that indicates they are ready for processing.
	[goal, icodebase-capability-request, capability-radar, solution-to-extant-problem, capability-unilang]

Should define a general purpose classification scheme - so that the system can get really specific about what it just classified.
	[capability-manager, shopping-list-item, complex-statement, observation, icodebase-capability-request]

Complex-statement for instance can be checked for using get_sentences
	[observation, shopping-list-item, complex-statement, capability-manager, unilang-specific-message]

Debugging UniLang is rather difficult and we don't want to fall prey to the same problem as with GNU Hurd.
	[capability-manager, goal, observation, shopping-list-item, complex-statement]

Now we have enough demos to definitely get people working on our projects.  Mike is right that I should learn persuasion.
	[shopping-list-item, complex-statement, unilang-specific-message, capability-manager, observation]

We have to hurry, though.
	[unilang-specific-message, observation, complex-statement, shopping-list-item, icodebase-capability-request]

You know, should set up regression testing soon.
	[shopping-list-item, complex-statement, capability-manager, unilang-specific-message]

Here is a random example of typical UniLang-Client traffic from the log file. Note that this is only traffic from the user, not the other agents. I have annotated them with very rough sample classifications. Often, one entry will initiate or continue a great amount of activity.

  • (PSE - add to BOSS todo) Replace all the uses of use Package qw ( F1 F2 ... ) and simply export these functions instead.
  • (PSE - add to BOSS todo) Document all programs soon, since I am already forgetting what they do.
  • (Bugzilla - file bug on RADAR) Status: Available through apt-get, yet sudo apt-get install libnet-google-perl says its already the latest.
  • (PSE - add to RADAR and Predator todos) Compute error probabilities for every phase of the RADAR-Predator system.
  • (BOSS - add to Machiavelli's requirements) Machiavelli should also try to estimate what other people are working on, so that we can be sure not to redouble efforts.
  • (BOSS - add to RADAR's requirements) Incorporate that special stuff for tracking upstream that I read in Wed Aug 4 21:23:53 EDT 2004 debian weekly news.
  • (MyFRDCSA - search capabilities) What are our video editing options?
  • (BOSS - add to Predator's requirements) automatic analysis of whether a package belongs to free/non-free, etc.
  • (Machiavelli - assert related group) http://acmsoft.org/ looks to be in a similar position to us.
  • (Audience - add to Eric's queue) send to Eric http://www.nitle.org/semantic_search.php
  • (BOSS - add to FRDCSA-website requirements) 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?

Currently, the corpus system still is mainly responsible for the classification of these logs. Additionally, we are working on adding translation capabilities between the various languages encountered, hence the name, UniLang. We will utilize a great many tools for this from the knowledge representation, linguistic ontological engineering, and machine translation fields. Examples forthcoming. Humorous unforeseen interaction.

  Lord, don't let me fall, don't let me FALL!
1UniLangUniLang-ClientMon Oct  2 22:41:05 CDT 2006No one here by that name.


  • unilang, deregister Emacs-Client
  • l unilang, deregister Emacs-Client
  • Fix unilang so we can run multiple processes off it. Also, make unilang run in a screen like Cyc and get connected to (possibly by multiple Emacs clients).\
  • Program unilang to start up by default.
  • Make unilang work with multiple Emacs simultaneously
  • Rewrite unilang to load automatically with emacs at startup after everything else is done.
  • Fix unilang Emacs Agent (uea) to be able to practically handle very large messages, such as those produced by 'elog -r'
  • Fix the issue with our encoding because findall current_atom(X) doesn't send through unilang correctly.
  • Write prolog functions for retrieving unilang entries, ie. unilangEntryFn(EntryID,Result). Figure out how to bind that properly.
  • Have session management for agents, such that if unilang is killed, we may restart and reload state of the affected agents as desireable.
  • Develop a Net::DBus interface for unilang.
  • 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.
  • Add a _DoLog flag to unilang, and have it automatically decide whether to log items that don't have a _DoNotLog or _DoLog flag
  • Set up audience-erc to send me messages via unilang when dmiles or jbalint surface.
  • Implement something that pops up a warning if it sees unilang, or similar misspellings.
  • We need to experiment to see if we could speed unilang up somehow.
  • Add checksums to unilang if wanted.
  • Have a recent command which lists recent unilang messages from unilang client, recent elog files, recent commits, etc. Just something that gives a snapshot of what was going on recently, or for example during a particular time span.
  • Add to corpus the ability to print date markers and such when listing recent unilang messages.
  • I wonder if we could use unilang as the record for IAEC, and have it fill out things and observations, just as I do, with provenance information provided. Maybe can even train on this.
  • Look into possibly adapting unilang to work with DBus.
  • Use sentiment analysis to get rid of rants from my unilang logs.
  • 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.
  • I wonder if we should take unilang entries like 'Also, do this' and if there is no agent for them, log them anyway as commands by the user - after trying first to autovivify.
  • make it so that running freekbs2-knowledge-editor will start unilang if it's not already started.
  • Have this rotate, so clear should read books for part of the day, old unilang messages for part of the day, text files from projects for part of the day, etc. Then we should watch a movie as recreation for part of the day, and so on. Develop a scheduler for these kinds of things. Use PDDL possibly. Have it know to not repeat the same subject. Have it directed by research interests in academician.
  • Maybe have clear read our unilang logs to us, selecting which ones are system messages versus ones written in English for us.
  • [Server /var/lib/myfrdcsa/codebases/internal/unilang/unilang accepting clients]
  • Agent unilang-Client registered
  • Add something to C-c s k to mention when unilang is offline.
  • Read our old unilang entries more.
  • It should be possible to define an extra type of syntax for KBS2::ImportExport such that what is currently processed as '("comment" ("unilang-entry-fn" "392228") "for academician")' would come out to '(comment (unilang-entry-fn 392228) "for academician")'
  • Match statements in unilang saying that something was completed with statements or tasks asking for that item to be completed, such as in SPSE2.
  • Fix the unilang test harness
  • Develop functions for asserting things about packages and systems. So for instance, we need to have cso interact with something to have bindings for asserting things associated with the systems. Like the previous unilang entry which states that dtrx can be used with packager.
  • Record all bad keys, like 'C-c C-k u p' killing unilang instead of starting update-frdcsa-git.
  • Create a unilang version of kbfs-tracker, change the commands in kbfs.el to use the unilang version.
  • Add authentication to unilang.
  • Add to unilang agents the ability to reconnect to unilang if and when it restarts.
  • 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
  • Apparently unilang or freekbs2 do not support \f character.
  • Add a knowledge source to freekbs such that it automatically has entries of the form '("has-NL" ("unilang-entry-fn" ) )'
  • Create a corpus mode and have a key for listing recently entered unilang entries.
  • Create keybindings for unilang that cause it to display messages more and such, using commands send to it via emacs-client
  • Fix the problem with not being able to receive messages that seem to be being sent by unilang to emacs-client from KBS2 in reply to a query agent.
  • Use KNext to process unilang logs.
  • Work on an automatic classification system that knows which context an assertion belongs to, similar to unilang's classification, and prompts to disambiguate.
  • Enable multiple Emacs agents to connect to unilang
  • Add error handling to unilang
  • If we get that repeating error in Emacs where it's having trouble communicating with unilang, try (kill-process <>)
  • Have spse2 automatically sync with to.do files, with unilang entries.
  • Make unilang so multiple emacs clients can connect
  • Put an ack into the unilang window so the user knows their message has been received.
  • Develop a way to know if unilang has died.
  • Add a key binding to unilang Shell to truncate the ushell buffer
  • Add a new capability to unilang, to be able to have agent types and send a message to any agent of that type.
  • Work to get classification of unilang entries.
  • Some things that people could work on: add performatives to unilang, make unilang use less processing power
  • We can use logic forms to capture the logic of the unilang entries, and textual entailment recognition to deduce CONC(A) etc.
  • We can take unilang entries as arguments in a Dung-style argumentation system.
  • Determine why assertions are failing to respond with freekbs2 and Emacs-unilang-Client
  • Add context to statements like: assert: ("assigned-to" ("unilang-entry-fn" "278806") "Andrew Dougherty")
  • Create a function to list the most recent unilang entries.
  • Create a notation for asserting classification tags for unilang entries.
  • Remove the possibility of error messages getting intertwined with messages from Perl to Emacs by switching to all unilang.
  • Reread some earlier unilang log entries, get back up to speed with the project, note where it has succeeded, where it has failed.
  • Add performatives to unilang
  • Inspect the unilang log.
  • Fix the unilang system for getting the ID of a particular assertion.
  • Verify that unilang notes are still working.
  • Inspect and clean up the unilang log
  • Get SPSE to use unilang goals again.
  • Hi unilang
  • Get the unilang system active again for recording messages....
  • /var/lib/myfrdcsa/codebases/internal/unilang/start -s -u localhost 9000 -c
  • KBS, query ("critic-unilang-classification" ?X ?Y)
  • Write something that prevents unilang from ruining an already running one.
  • use this /var/lib/myfrdcsa/codebases/internal/unilang/scripts/convert-perl-to-emacs-data.pl for the freekbs-es system
  • KBS, work query ("critic-unilang-classification" ?X "goal")
  • KBS, query-cyclike ("critic-unilang-class" ?X)
  • KBS, query-cyclike ("critic-unilang-class" ?X ?Y)
  • KBS, query ("critic-unilang-class" ?X ?Y)
  • Write something that searches through my unilang entries when I am having a question to see if there is an answer.
  • Fix unilang timeout issues causing errors.
    ("due-date-for-entry" "106974" "3 days")
  • Write something that prevents running C-cru when there is already a unilang running.
  • Exhaustively determine the meaning of all manually added unilang entries.
  • do get my resume done. As for importance of a given topic, compute it by NLP over the unilang entries. For instance, if resume is appearing more frequently than it should statistically.
  • Write something that classifies unilang entries by taking all the addressed messages, stripping them of their addressed names, and then running a feature learner over the text.
  • Convert the data segment of unilang messages to xml serialization or something.
  • fix backslash screwing up unilang entries
  • Allow multiple unilang-clients to connect with one unilang instance
  • Create a timeout for unilang query agent calls.
  • Figure out delays with unilang
  • Enhance posi-unilang-bot, adding all the features we envision
    ("due-date-for-entry" "102954" "12 hours")
    ("pse-has-property" "102954" "very important")
  • KBS, default query ("critic-unilang-classification" ?X "donation-request")
  • KBS, default assert ("critic-unilang-class" "donation-request")
  • KBS, default query ("critic-unilang-class" ?X)
  • Create an entry method for entering to unilang without using unilang-client, but through uea
  • Have unilang make it's own decisions about what to log.
  • /var/lib/myfrdcsa/codebases/internal/unilang/start -u -c
  • Maybe add a _Log entry and don't log anything to unilang without it
  • What happens when unilang uses all the IDs.
  • evangelist or hypermedia or whatever can control Emcas over UEA. Elements should be generalized into interfaces, to allow user input bcak from the different programs. Other programs can schedule elements. all interaction takes place as interactive movie. Can be used for collaborative/telepathic interface. Use unilang to distribute data over network. Add authentication to unilang over iSAKMP VPN.
  • Another thing is: need to get Justin using unilang, so he has more ideas. Need to get him the $250 Dell Computer, running our software.
  • /var/lib/myfrdcsa/codebases/internal/unilang/start audience broker clear corpus cso ELog OpenCyc pse unilang-Client
  • Could have a specific messaging format for unilang.
  • Determine whether using ID will break unilang.
  • The planning system should actually send messages over unilang and all the programming be handled in Perl.
  • It is recording the messages send back from corpus to unilang-Client, not necessarily relevant.
  • sinless should record what type of temptation the user experienced and log that through event stream or unilang.
  • unilang should do basic RPC.
  • Note that unilang should become a system service.
  • Let's get manager going by turning him into a unilang agent and allowing him to send messages, or execute programs. For instance, if the daily items haven't been done by the end of the day, manager reports that.
  • Get Brian using unilang so he helps develop clear.
  • unilang agents should, defined through audience, have a nominal state that allows unilang while dynamically starting them upon messages received for them (so they don't all have to start at once), that indicates they are ready for processing.
  • Turns out there is no problem with unilang sql data, just with my visualization script.
  • unilang client or the like should be able to run shell commands. Example is if clear crashes, and we want to restart it within the window, without having to restart everything.
  • Check out "error in process filter" error with Emacs-unilang-Client
  • We can extract project creation and renaming information from the unilang log by looking at first appearances of new names...
  • Immediate subgoals: get unilang logging to SQL.
  • Should use WSD on corpus entries and also run ExtractAbbrev.java on them to get abbreviations like Emacs unilang Agent, run this through termios, and use that to boot strap translation. Also do anaphora resolution by running it on chunks of aligned texts.
  • Write some Emacs wrappers for Emacs-unilang-Client. In fact, specify the entire API.
  • Justin would be more productive (possibly) with unilang.
  • Debugging unilang is rather difficult and we don't want to fall prey to the same problem as with GNU Hurd.
  • Adapt unilang to use SQL.
  • 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.
  • 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.
  • I think we should have some kind of autoformatting for unilang.
  • Should we have an unilang SQL agent?
  • Write functinoality that will allow unilang to start agents itself
  • Improve the unilang naming scheme.
  • Should add a prompt to unilang-Client
  • Need to figure out the unilang name system very quickly.
  • Looks like, if they can use Weka for information extraction, I can use it for classifying unilang messages.
  • Should put an authentication layer into unilang.
  • unilang agents should have a message QUEUE as part of their API.
  • Use a model of textual context to provide addition information that could use LSI for classification and clustering - to improve accuracy of unilang stuff.
  • Have unilang automatically deregister closed lines.
  • They could use unilang to send messages reporting violations.
  • (The key to this is to get unilang using SQL for its logging)
  • We can extract project creation and renaming information from the unilang log by looking at first appearances of new names...
  • Immediate subgoals: get unilang logging to SQL.
  • Check out "error in process filter" error with Emacs-unilang-Client
  • Adapt unilang to use SQL.
  • Turns out there is no problem with unilang sql data, just with my visualization script.
  • Note that the unilang data is corrupted in the sense that when converted, the max hour is 12:59:56
  • Could have a specific messaging format for unilang.
  • Determine whether using ID will break unilang.
  • I think we should have some kind of autoformatting for unilang.
  • Have to deal, during classification of unilang messages with the possibility that it is actually a multipart.
  • Debugging unilang is rather difficult and we don't want to fall prey to the same problem as with GNU Hurd.
  • Remove elog entries from unilang and get it filtering messages.
  • Note that unilang should become a system service.
  • Make sure the unilang entries are also color coded.
  • Depending on the mood of the user, unilang can ask questions to disambiguate entries.
  • Predict unilang-Client entries.
  • Probably want to convert unilang to a system service pretty soon.
  • Fix problem with unilang hogging everything.
  • Definitely fix problem with unilang hogging the processor.
  • In fact, any task should relate to some entries in unilang as well as specific code.
  • unilang should give messages or talk to the user if it fails to log to SQL or some such thing.
  • Every now and then unilang just kind of dies.
  • Should use a tags system to boot strap the classification of unilang notes.
  • unilang should really function as an /etc/init.d/ service.
  • In some sense unilang is mistaken because the simple TODO file mechanism would suffice?
  • Figure out why unilang is not starting correctly the first time.
  • Integrate email and unilang processing of todo items.
  • unilang should store messages for agents if they are not active.
  • Create a fortunes file from my unilang db.
  • Figure out how to use a different mechanism for unilang messaging.
  • Write pid software for unilang.
  • Use Jabber for unilang backend?
  • unilang should support RPC.
  • Write code to lookup contents of unilang message from ID.
  • Need to resolve time issues with unilang now that it is being used for certain important tasks.
  • unilang should have the capability to disconnect idle agents.
  • sinless should record what type of temptation the user experienced and log that through event stream or unilang.
  • Replace fortune with unilang or score messages.
  • unilang/pse should also consider the changing landscape of requirements, when asserting these.
  • Could write a manager::Dialog interface for unilang.
  • Just have to unilang enable manager/Spark
  • unilang should do basic RPC.
  • In order to use critic in Emacs on Sorcerer data, simply send the list to unilang-emacs-client via some new function that converts it into an alist and browses it with some dired like editor.
  • Use picform Contexts for unilang classification, study assignment, etc. Eventually, develop Context classifier as part of critic?
  • (Here is the todo for unilang/corpus/pse)
  • It is recording the messages send back from corpus to unilang-Client, not necessarily relevant.
  • Add duplicate detection to corpus feedback for unilang.
  • /var/lib/myfrdcsa/codebases/internal/unilang/start corpus ELog unilang-Client
  • Or they could use a standard length like "AUDIENC: unilang: clear--: BUSROUT: etc
  • Solve problem with unilang-client quitting when using clear.el stuff
  • Can apply clear topic jisting to unilang messages.
  • /var/lib/myfrdcsa/codebases/internal/unilang/start audience broker clear corpus cso ELog OpenCyc pse unilang-Client
  • /var/lib/myfrdcsa/codebases/internal/unilang/start audience broker clear corpus cso ELog manager OpenCyc pse unilang-Client
  • Maybe we can determine all instances of unilang debugging and not record those or something.
  • What happens when unilang uses all the IDs.
  • unilang agents should, defined through audience, have a nominal state that allows unilang while dynamically starting them upon messages received for them (so they don't all have to start at once), that indicates they are ready for processing.
  • The planning system should actually send messages over unilang and all the programming be handled in Perl.
  • Have it generate long flags like ./unilang-command --upload-all-contents-of-wiki
  • note that I'm not sure all unilang.xml messages made it into the system.
  • Should be able to start an agent from this window, have a unilang, start agent audience, type feature.
  • Come up with agent debugger framework for unilang.el, that is, you load it up and it helps you debug the unilang agent you are developing.
  • Should we have an unilang SQL agent?
  • If an emacs unilang agent command finds that unilang is not running, start it.
  • unilang should also reply that the agent is not active.
  • Reintegrate old unilang messages from multiple sources.
    ("due-date-for-entry" "88273" "1 days")
    ("pse-has-property" "88273" "important")
    ("completed" "88273")
  • Add message ids to unilang messages
  • Add automatic detection of questions to unilang..
  • 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".
  • Many programs make the assumption that the only items worth analyzing are those from unilang-Client. So do we refactor that? Absolutely.
  • Take most problematic comments right out of unilang log and into a private file.
  • If unilang get's excessively loaded, just restart it.
  • Add a feature to unilang, enabling it to tell us some stats, like how many open connections it has.
    ("completed" "84358")
  • I bet unilang isn't dropping all it's connections. Need to have it send out "ping" messages every now and then.
  • Notice that unilang gets slower as time goes on.
  • Make an effort to classify existing unilang entries.
    ("pse-has-property" "81599" "habitual")
  • Process my unilang entries with assert...
  • Create a new system for adding things automatically to the completed pile, by typing them into unilang, i.e. completed: setting up researchcyc
  • Create a multi-user element to unilang...
  • Create an interface that allows me to say something to unilang from anywhere.
  • Fix unilang...
  • Create a search functionality for unilang goals, to retrieve the ID of a given goal based on not just phrase but content matchin.
    ("same-as" "68027" "68444")
  • 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")
  • Setup unilang conf files so we can have multiple unilang instances on the same machine.
  • Get freekbs working on irc_log entries like it works on unilang entries now.
    ("depends" "67342" "67356")
  • Have some kind of indication unilang-client messages are received.
  • Remove nonsense about spoof-unilang-client
    ("completed" "66122")
  • Replace (comment ) with (comment (unilang-entry-fn ))
    ("pse-has-property" "65975" "optional")
  • Expand the freekbs system to do more than just unilang entries.
  • KBS, MySQL:freekbs:default query ("unilang-message-classify" nil "political-action-item")
  • KBS, MySQL:freekbs:default assert ("answer-unilang-question" "29229" "yes")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "44537" "political-action-item")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "45505" "deleted")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "50420" "political-action-item")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "60762" "observation")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "28838" "observation")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "57737" "political-action-item")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "60303" "icodebase-capability-request")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "60841" "observation")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "59191" "delete")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "55600" "icodebase-capability-request")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "59525" "event")
  • KBS, MySQL:freekbs:default assert ("arg-isa" "completed" "2" "unilang-entry-id")
  • KBS, MySQL:freekbs:default assert ("arg-isa" "completed" 2 "unilang-entry-id")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "59603" "icodebase-capability-request")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "59611" "icodebase-resource")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "59642" "complex-statement")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "55512" "icodebase-resource")
  • KBS, MySQL:freekbs:default assert ("unilang-message-classify" "59642" "rant")
  • Write a unilang command to deregister all temp-agents
  • unilang ,deregister temp-agent-0.404671405765356
  • Write something that forces me to review unilang entries periodically, by showing me ones it's confused about.
  • Convert lookup-entry.pl to a unilang agent? No just make it part of freekbs.
  • Convert lookup-entry.pl to a unilang agent?
  • Fix problems with unilang QueryAgnet
  • Find-or-create unilang RPC
    ("depends" "61728" "61722")
    ("completed" "61722")
  • Figure out where the fuck the unilang RPC code got to. I don't want to have to rewrite that.
  • Analyze patterns in unilang log to see if there is something that should be set to _DoNotLog
  • One way we can deal with problems where there are multiple unilang entries having the same contents, is to just select the latest.
  • Get facebook to post to twitter, or whatever, even better have unilang sort that out.
  • Create an RT agent for unilang that has messages routed to it for new tickets, etc.
  • Alter the way freekbs comments, by having it assert the entry into unilang and then say ('comment' '135983' '32523')
    ("completed" "59226")
  • Sayer: the problem is similar to the unilang classification problem. of course I knew this. however, for instance, like the problem of multiple dispatch, could be solved by training a learner. like the problem of longest token for the perl 6 parser. all related. The problem of figuring out what function to call based on the type of inputs.
  • Bugs can be reliably retrieved by searching unilang messages for "fix"
  • 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 search engine for unilang messages.
    ("depends" "53591" "53588")
  • Perhaps unilang should be able to open up interaction sessions with users.
  • It appears unilang-emacs-agent cannot accept large messages.
  • The Textmine:: question classifier isn't working well enough on our unilang question log.
  • Maybe want to load unilang entries into an information retrieval engine instead of corpus::Sources.pm
  • Create a command for similarity search through unilang.
  • Have to anticipate how to deal with scalability of unilang with it recording so many messages...
  • What is the name of the command to search unilang histories?
    ("comment" "47827" "it is currently corpus -s (search)")
  • Sayer is related to the unilang message classification.
  • Figure out a way to do twitter from unilang so it is dual logged.
  • Should corpus be renamed since it is so unilang specific?
  • The corpus system for routing unilang messages can use the thinker/notes system.
  • Start processing unilang logs.
  • Audit unilang entries to track development of psychosis.
  • Write a script to attempt to locate a dump of some form of the unilang database during the missing times.
  • Need to get something similar to corpus::TDT::GetEntries for working with unilang entries.
  • Develop tool for searching unilang logs.
  • 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?
  • This DCOP looks very much like unilang.
  • Centralize all the papers I've written about stuff like unilang, etc.
  • Apply classify to unilang log entries.
  • unilang should test a connection before insisting the name is already taken, it may have been dropped.
  • unilang should log a message whenever it starts up.
  • Develop a way to send messages to different unilang agents but not log them.
    ("completed" "16888")
  • unilang should automatically tell agents to shutdown after a while if they are not preserving some important state.
  • Add something to unilang to prevent it starting from just any directory.
    ("completed" "14814")
  • I should set it up to send and unilang message.
  • Note we need two unilang-clients running, so that we have a client for each emacs
  • Implement a scheme for having classes of agents on unilang, so that we can deal with that information.
  • Successfully test connecting to unilang from a remote system.
  • Create a new system for unilang in which agents are of differing types, or at least a service model.
  • Get it so multiple instances or at least unilang-clients can run
  • Make the unilang code autovivify all messages by creating a function and replacing the corresponding parts with a function call, every time any message is sent, not just through "," syntax
  • Note that the autovivification of unilang agents does not work when the message originates from unilang itself.
  • Fix unilang nonsense.
  • Perhaps unilang can ping things every now and then.
  • Add the ability for unilang to automatically deregister given sockets.
  • unilang agents that are not used in a long time relative to their loading expense should be shut down.
    ("comment" "9369" "and relative to their running overhead")
  • It would be interesting to add conversational agents to unilang.
  • Fix the , problem that unilang has
    ("completed" "9361")
  • unilang agents should, defined through audience, have a nominal state that allows unilang while dynamically starting them upon messages received for them (so they don\'t all have to start at once), that indicates they are ready for processing.
    ("completed" "9355")
  • Several problem's need to be resolved before unilang functions properly
  • Make sure unilang switches to a sane dir when executed.
  • unilang checkout dbus
  • unilang should have "daemons" that aren't running but load dynamically.
  • Write a test daemon that connects to unilang, stores its pid, daemonizes, and writes to log files.
  • unilang should have some kind of status system and maybe even a panel applet or something.
  • Fix unilang hogging the processor!
  • unilang should have a short expire time set for certain messages, and then periodically delete these.
  • Periodically unilang should see if all sockets are still open and if not, close them and remove the agent from the DB
  • Periodically, unilang should see if all sockets are still open and if not, close them and remove the agent from the DB
  • 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.
  • Check that messages contents that match /^\w+,/ are being archived by unilang log
  • Come up with grammar for using busroute, to allow it to be used over unilang.
  • Fix bug with unilang-emacs-agent, where it aays args out of range, when receiving certain messages
  • Convert unilang to a system service
  • Making Emacs into a unilang agent greatly increases our abilities here.
  • One possible thing to do is write something for unilang that interfaces with the corpus classifier.
  • Convert busroute to be a unilang agent, by tomorrow
  • Perhaps unilang messages ought to be stored in an sql database.
    ("completed" "3362")
  • If it's not obvious, unilang will be using corpus to classify the users entries.
  • wow I got corpus working sort of. That's good news. It is now classifying unilang log messages,a dn doing a rather good job.
  • The unilang interface does not serve this need.
  • /var/lib/myfrdcsa/codebases/internal/unilang/start pse OpenCyc unilang-Client
  • Josh seemed to like the unilang system.
  • Also need unilang or corpus to record which messages have already been addressed.
  • 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.
  • Of course, make sure to use Conversation perl module in corpus analysis of unilang.xml
  • We need to make more use of web services, we have to index them, and use them. Perhaps, they could interact with unilang using wrapper agents. In any case, we need to take account of these services, locate them, and use them. We also need to identify existing ones, such as CPAN, deb apt archive, google, altavista-translation, gutenburg, uh-oh, etc.
  • Move the log reading utils to unilang and provide searching and so forth of logs.
  • for unilang?: http://freshmeat.net/projects/pkt/?branch_id=50215&release_id=186636
  • for unilang?: http://freshmeat.net/projects/pkt/?branch_id=50215&release_id=186636
  • In case I forgot to mention this, run clustering on unilang-client logs.
  • Ensure that unilang messages which are being incorrectly interpretted are nonetheless still being logged.
  • Commission study of performance issues for event.pm given current unilang system
  • Change that "stream of consciousness MAS" thing on unilang - looks silly
  • unilang might employ routing rules.
  • Now here's the kicker, its obvious now that we want a way to send perl data structures over unilang.
  • In this way, way point routes can be had. I wish we had a waypoint DB of CMU's campus. I suppose that would not be too hard to generate. It would be nice to have connectivity information gleaned in this way. The most important point of all of this is prevent me from making the mistake of say going to the undergraduate lounge. Permission for any movement is to be had. Also, permission for any social interaction is to be had. Machiavelli, I suppose, must ultimately represent this list, not audience. Agentifying everything has the negative affect of forcing a certain design philosophy on all software, and a bad one at that since unilang is so primitive conceptually.
  • For all agents. I.e., unilang::Agent::Agent should parse that automatically.
  • Need to incorporate classification technology into most systems. Such as, don't log classified concepts in unilang, etc.
    ("rejected" "362")
  • Build an ontology of unilang messages, so for instance, some of them will be of the type "Yam would assist radar", i.e., relations asserted between software systems.
    ("comment" "321" "this is called \"intersystem-relation\"")
  • /var/lib/myfrdcsa/codebases/internal/unilang/start pse opencyc unilang-client
  • (Just checking that time management was fixed in this version of unilang).
  • 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.
  • 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.
  • unilang should determine accidental inputs of the above form and prompt their removal, only if it does not interrupt a useful train of thought.
  • I could conceivably give this unilang file to Al for total project transparency, as a module which he could read using clairvoyance.
  • I think that I could ask someone at the bug squashing party to write a classifier for the unilang file that does the automatic stuff (although I don't know anyone who can do that, we'll have to find them. It would be a cool way to get stuff done, to have the code online and these people would improve the code at the meeting, and we would reward them in someway, such as giving them more code in exchange, etc. The FRDCSA could simply be the wrapper, or the project information site, for everyone's projects, and in this way we would do this. We could alternate who's projects we worked on each time, or something, if necessary :)
  • 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.
  • /var/lib/myfrdcsa/codebases/internal/unilang/doc/older/unilang.
  • We should add this kind of thing to unilang: shops, baseball cap.
  • Need to add a function similar to LAS to meeting, so that I can edit the meeting plans whenever. More generally, this should be part of unilang I believe.
  • Need to figure out a way to classify my unilang.log adequately.
  • 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.
  • Not only should unilang/myfrdcsa send api function requests to various programs, automatically create them, etc, but it should also track their completion/obselecense.
  • Must specify exactly how we intend to use the classification system. Does it interface to unilang directly? Or perhaps Machiavelli. What about performance issues.
  • manager should be tied into unilang. unilang should run as a server using /etc/init.d. The problem right now is unilang hogs the CPU cause of Event.pm insanity.
  • Machievelli ought to parse unilang-client input and automatically classify it to an appropriate level.
  • /home/jasayne/frdcsa/source/unilang/doc/older/unilang.pl
  • I think that with unilang we simply have to ensure that all watchers have a timeout.
  • That would then allow us to use programs over unilang to query the cyc server with questions about things in the various programs.
  • use TempEx or other temporal taggers to extract temporal information from unilang feeds to identify the temporal references.
  • could possibly write a pymacs client to bridge Emacs and unilang
  • 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
  • make a corpus agent that allows interactive classification of existing entries and sends these to the respective clients over unilang.
  • here is another thing to do, simply operate on the ones in this convenient unilang format
  • /home/jasayne/frdcsa/source/unilang/doc/older/unilang.l
  • I was thinking that boss could handle FRDCSA.xml files and specifically would be able to, interfacing with unilang, add feature requests, dependencies, etc, all project related information to the file with tagging of which messages justify the inclusion.
  • unilang is useful for those who think nonlinearly because as soon as they have a thought they can record it and have it properly analyzed and put in place automatically. Thus we avoid some difficulties of goal directed problem solving.
  • should capabilities requests through radar automatically be recorded through unilang? I think they will certainly go through it since that is probably how it will communicate with the capabilities manager, etc.
  • When we incorporate the event based system, we can use its built in priority system to help with unilang.
  • critic.el can communicate with critic.pm through unilang.
  • at some point we'll need to keep a database of all things the user has ever typed into unilang. And then, those which are deemed to be a certain type etc, can register themselves with other agents. We should also have all agents support recall of a message, i.e. some support for negating the contents of a message. How does this affect things? We can keep a database of which agents implement which core functions.
  • now that this is working I sort of see how this could be very powerful. for instance, you might consider having "shout" functionality, etc. what's also very interesting is that you could for instance have unilang talk with Machiavelli depending on whether the agent was an interface client for a human. By using agent type information, for instance, unilang could also be generally suited to handle many requests for services from other agents, and route them as well. Additionally, we should add the ability for multiple unilang servers to talk "directly" to each other. In every case the proper filters would be applied to ensure that communciation was authenticated, and socially appropriate, and respected classification, etc. For instance, what was being said would depend very much on Machiavelli's calculations about who was listening and where they were going to spread that information.
  • in this way we could for instance ask for a list of agents from unilang.
  • unilang should respond to messages containing commands with messages containing answers
  • critic could possibly even use unilang to communicate, say, task dependencies to pse.
  • No, I see, so that really is an error with the old version of unilang, in that the messages get date from the previous message.
  • well, obviously since my system says it is 4:42, but unilang says its 4:07, somethings screwy there.
  • some things that need to be done: fix date to be supersecond and better format, rewrite unilang to be event based.
  • this way we can readily determine how we've classified it before. As well, we can simply send the file contents over unilang.
  • fix problem with unilang::MAS, unilang::MAS::Server, thinking Server is part of unilang::MAS
  • -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.
  • make some kind of request-tracker3 CLI for unilang
  • get unilang search capabilities going. use critic on unilang!!!
  • here are some dependencies: pse unilang ?, pse myfrdcsa::Conf ?, pse critic?
  • we can use unilang to follow steps of reasoning in problem solving for instance:
  • Look into debconf etc, for unilang interactive dialoging facilities
  • o/home/jasayne/frdcsa/source/unilang/older/unilang.pl
  • start initiative to allude to the israeli peace process/home/jasayne/frdcsa/source/unilang/older/unilang.pl
  • mico corba unilang
  • libmalaga for unilang
  • use corba for unilang?
  • must be sure to differentiate unilang statements that are generated from other systems. also, some thought should be put into representational efficiency. For instance, if it thinks that the perl module WWW::Wrapper belongs in frdcsa-perl, and that in general perl module X belongs to source Y/home/jasayne/frdcsa/source/unilang/older/unilang.pl
  • we could use unilang to pass events or to announce events to many agents.
  • This problem domain is of course entirely out of our capability to solve, so I am writing unilang and pse to make things simpler.
  • w/home/jasayne/frdcsa/source/unilang/older/unilang.pl
  • 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.
  • hold a meeting with some people from CMU to determine /home/jasayne/frdcsa/source/unilang/older/unilang.pl
  • /home/jasayne/frdcsa/source/unilang/older/unilang.pl
  • progress on the thoughts corpus will be slow until the mess with unilang is sorted out.
  • r/home/jasayne/frdcsa/source/unilang/unilang.pl
  • For now, the unilang we have will be relatively sufficient.
  • 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.
  • Well I got a lot done, especially on unilang. I should back it up to CD tomorrow first thing.
  • 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.
  • The main goals right now are to overwrite unilang with the new version, get that interlanguage stuff to work, then collect and implement basic pse features that can be handled effectively by custom code and/or existing modules, but (probably) little reliance on external code as we can't very well use it yet. Should also make sure that the representational components are independant of the computational components, i.e. don't rely strictly on an XML pipeline.
  • should give unilang some nice emacs features too, just like radar, but these need to be integrated at some point. Need to learn OO Elisp, as well as create some eigencomponents or templates for emacs like stuffs.
  • Should look into existing text translation/processing tools for unilang.
  • Into unilang, I mean.
  • improve the cohesive properties of unilang data, for instance, make sure it is all saved under ~/.unilang
  • come up with a standard file format to describe a unilang corpus
  • /home/jasayne/frdcsa/source/unilang/unilang.pl
  • Calculate WPM on the basis of how many words are being typed in unilang, to calculate channel capacity.
  • Create a corpora of unilang texts.
  • Look into automatic spelling correction. Also, wow!!!!! You can use unilang to learn phrases, so you simply need to incorporate a phrase learner.
  • This unilang tool.
  • But sooner, unilang wasn't working.

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