coyled.com

A hearty welcome to #bshellz

coyled@coyled.com (Dave Coyle) — Thu, 27 Jan 2011 15:29:16 -0500

There's been a request to me to bring the bot into #bshellz for helping with users that don't speak english very well. So i'm writing up a small tutorial for them on how to use the translation api in Farnsworth. Here is a list of languages currently supported. Any more that google adds to it's translation service I will add as I get time.

Arabic  Bulgarian  Catalan  Czech  Danish  German
Greek  English  Spanish  Estonian  Finnish  French  Galician
Hindi  Croatian  Hungarian  Indonesian  Italian Hebrew
Japanese  Korean  Lithuanian  Latvian  Maltese  Dutch
Norwegian  Polish  Portuguese  Romanian  Russian
Slovak  Slovenian  Albanian  Serbian  Swedish  Thai
Filipino  Turkish  Ukrainian  Vietnamese  Chinese  Chinese_Traditional

How you use these is like this.

(you) farnsworth: "I do not speak your language" -> Spanish
(farnsworth) you: "Yo NOTY hablan su idioma"

Now this is all very well and good if you know what language they are speaking, but what if you don't?

(you) farnsworth: "Jinsi gani mimi kupata shell yako na kukimbia exploits mizizi juu yake" -> DetectLanguage
(farnsworth) you:  "Swahili"
(you) farnsworth: "Jinsi gani mimi kupata shell yako na kukimbia exploits mizizi juu yake" -> English
(farnsworth) you:  "How do I get your shell to run exploits on his roots"

Now there are also other features on the bot, math related that you can explore here on the rest of my site.

Hire Me!

coyled@coyled.com (Dave Coyle) — Fri, 07 Jan 2011 19:12:33 -0500

I've come into the need of some employment so I'm posting my resume up here for all to see, and offer me a job. You can view my resume here.

¡Ándale! ¡Ándale! ¡Arriba! ¡Arriba!

coyled@coyled.com (Dave Coyle) — Tue, 28 Sep 2010 19:21:32 -0400

Thanks to a friend of mine I've now got something like a CDN setup to help accelerate the site no matter where I end up hosting it. This means that the site should go quite a bit faster than it used to and It's given me a reason to actually learn Python. This has given me a few ideas for possible syntax and features that might be useful for both the module system and other things for the language.

And we’re back in 3 2 …

coyled@coyled.com (Dave Coyle) — Thu, 23 Sep 2010 11:54:37 -0400

Ok i've been struggling with my webhost for a while now, it was free but the service was getting horrible and I think they've gone down for the count. As such i'm now hosting it elsewhere and we'll hope this one is more stable (though i do know they don't have very much backup power but it shouldn't be a problem).

Has it been that long already?

coyled@coyled.com (Dave Coyle) — Sat, 11 Sep 2010 00:00:41 -0400

As of today, it's been two years since the first commit I made to start this project. It started out as an open source clone of another program so that people (mostly me) could use it for doing some math on IRC and have all kinds of fun figuring out how many farts it would take to power a laptop. Since then the project has grown wildly out of control and I couldn't be happier about it. It's still not even close to anything that I'd call stable or ready for production BUT it's getting there. With this project I've learned a considerable amount about creating a testing suite. I've also had to do a number of redesigns because what I had made wasn't quite as flexible as I later needed it to be.

I've got a number of plans for the future and some of them can be seen on the Todo page, but there's one big one that isn't on there. I am planning on writing a compiler for the Parrot VM and I'm intending to have that as the canonical version of the language once I've finished defining most of the features inside the Perl modules.

I'd like to thank all of you that visit, (not counting spammers that appears to be about 3 of you, maybe); and please register and leave a comment if you're out there.

Version 0.7.6 released

coyled@coyled.com (Dave Coyle) — Fri, 03 Sep 2010 09:59:01 -0400

This version brings very few changes from the 0.7.5 release (that i forgot to announce). Most notably is that the tests are fixed, I SWEAR they worked here! Along with that I made the date parsing stuff save time zones when given rather than converting everything to UTC by default, this means when you tell it #2010-03-14 1:59:26am EST5EDT# it'll keep it in the EST5EDT timezone for you. I also removed a single reference to Date::Manip which hasn't been strictly needed for some time and I just kept missing the reference.

The 0.7.5 release brought the new function syntax and the depreciated & operator.

This release is because I'm planning on doing something special for the 2 year anniversary of the project next Saturday, keep an eye out!

What does it take to become useful?

coyled@coyled.com (Dave Coyle) — Sun, 22 Aug 2010 13:54:53 -0400

I'm getting ready to prepare a new release of Language::Farnsworth with some of the new features I've added before I start work on the module system. The reason being is that the module system is going to require some massive changes to the whole interpreter. These changes will cause me to have to refactor lots of code and end up with a more complete design for an interpreter. I'm updating the TODO on here to reflect what I need to do before I finish this. I've also added a minor design document on how I plan on adding "lazy" type evaluations at todo/magic-values/

Someone check the temperature of hell

coyled@coyled.com (Dave Coyle) — Thu, 19 Aug 2010 09:38:09 -0400

Ok I've gotten my notes up as a preliminary spec on how modules are going to work in Language::Farnsworth. You can view it at docs/module-draft-spec/ . I'd like you guys to check it out and leave me some comments on it.

Request For Comments

coyled@coyled.com (Dave Coyle) — Tue, 10 Aug 2010 18:06:50 -0400

I've been considering how i want to make namespaces in farnsworth and the way i've used them is quite considerably influenced by my experience with perl. On the filesystem I think the way perl handles it (e.g. POE::Component::IRC is the file POE/Component/IRC.pm, by convention and by the fact that C<use> expects to find them there) is probably the way to go. But should I have the actual creation of the namespace up to the file, or should i have it enforced like in java? Just some things for me to mull over but I would love to hear from anybody out there on the topic. So PLEASE leave a comment?

Free CPU time

coyled@coyled.com (Dave Coyle) — Sun, 08 Aug 2010 16:04:48 -0400

I've finally gotten an Evaluator working here so that you guys can play with the language without having to spend large amounts of time figuring out how to get the damned thing running yourself! This means you can spend my money and cpu time (in 25 second increments) to play around and have fun!

[eval-form 1 "Contact form 1"] There is a 25 second timeout setup so any infinite loops will still halt.

Intentionally Unsupported

coyled@coyled.com (Dave Coyle) — Sat, 07 Aug 2010 23:59:35 -0400

The following feature is intentionally unsupported since it has come into being while being considered depreciated until a more permanent and logical system can be created.

To go along with all the other changes I've made I have added in a new operator that lets you get at the actual value for a function so that you can do some rather nifty things with it

&push

And what you'll get is something like

{`arr byref isa \[\] , x isa ...` arr = arr + x; }

While this might seem a little pointless at first it'll let you do things like alias one function to another without having to create a new stack frame and function to accomplish it.

defun foo={`x` x * x};
defun bar=?

Now that too seems a little pointless since you could just define both of them to be the same to begin with, BUT when you've got a large function that you don't want to have to copy and paste to multiple places it ends up very nice since you can have the interpreter do it for you. Now the really nifty part is that you can redefine an existing function while keeping around a copy of the original so that you can call back to it. This lets you create an automatically memoized version of an arbitrary function (assuming you know the inputs) and other really nifty and nasty things. I'm going to write a quick and dirty little memoization system in a bit to demonstrate this.

Speech Impediments

coyled@coyled.com (Dave Coyle) — Sat, 07 Aug 2010 20:00:20 -0400

I've finally gotten all the work done on merging the lambda and function code. This resulted in a slight API change that nobody cared about because there isn't anyone else out there doing anything with this. The new syntax looks like this:

defun function=lambda

What this means is that you can define a function by creating ANY expression that evaluates out to a lambda and assign it to the function. So you can do something like this:

defun count={`` var count=0; {`` ++count}} \[\];

Then when you use the function count[] it'll increment the variable every single time and return the value. This makes for a slightly nicer looking way to make static values between function calls since before you'd have to do something like:

{``  var count=0; count{} := {++count}} \[\];

Which can start getting rather nasty looking to work with and debug when you start to have large functions or large amounts of static variables (Though when you have multiple functions sharing the same variables you can still use this form).

Planned obsolescence

coyled@coyled.com (Dave Coyle) — Wed, 04 Aug 2010 22:50:11 -0400

I've decided that i'm going to be removing the unit\[\] "function" since its using a different part of the api that I don't like anymore. I also suspect that none of you are using it (who are you guys anyway?). I'll be replacing it with an operator instead since that's really what it was. I don't know if i'll keep that operator around forever or not but it will most certainly be with more notice and more thought about removing it. Let the complaints begin, (pretty please? someone? is there anyone out there?)

That's it I'm turning this car around right now!

coyled@coyled.com (Dave Coyle) — Fri, 30 Jul 2010 13:36:41 -0400

Ok, I've just pushed some changes to the git repo (http://github.com/simcop2387/Farnsworth ) that FINALLY adds code for doing return\[\] finally. I've also added tests for it, since I'm sure I'm going to break it. This marks a wonderful day for Farnsworth since it now allows you to write code that isn't perfectly rigidly structured! I've got one more error message to rewrite and to add the new function syntax so that I can finally get other things I want in place (mostly objects).

Error messages and the values of functions.

coyled@coyled.com (Dave Coyle) — Sun, 25 Jul 2010 17:13:42 -0400

I've spent a good deal of time recently getting rid of all the calls to die and friends in the code and switching them to the error reporting module i've made so that i can start adding exceptions and a proper return\[\] to the language. I've also finally cleaned up the massively strange looking error when you try to convert between incompatible units, Conformance error, left side has different units than right side $VAR1 = bless( \[ 'kg' \], 'Fetch' ); that didn't even tell you about both sides to one that's much more readable and understandable Conformance error, can't convert from length to mass.

I still have one more error message that i know of that is incredibly obtuse and that will come next. Now that i've switched away from using die directly i can start making an error object that i pass around instead so that i can differentiate between an error and a return value. I needed this because i need to use die in perl to smash the stack and go back to the point where the function or lambda was called. This is all because currently I'm using a recursive descent pattern to evaluate the AST from the parser (I'm not doing any processing on the AST for optimization or even to order operations directly so that i can avoid deep recursion, it is a design flaw but it makes hacking on it SO easy.) After i finish this error code stuff i'm going to begin working on the rest of the stuff needed for merging the lambda code and function code which amounts to creating an operator (currently thinking of using ~) to get a reference to a function and then moving to the new syntax, defun foo={`bar` bar ** 2}; I'll keep the old style syntax around for some time though.

Documentation, documentation, documentation

coyled@coyled.com (Dave Coyle) — Thu, 03 Jun 2010 10:03:13 -0400

I'm getting ready to reorganize/restructure the units in Farnsworth so that they can all be documented (and make it so that ancient units and things can be easily excluded/included in a script). While I'm doing this I want to be able to make some nice documentation and make an official way to include and document code written in the language. To that end I'm getting ready to start extending doxygen so that it can be used to document all the code written in Farnsworth can have documentation included fairly easily. I'd also love any comments and suggestions for other systems if someone knows one that's better; the only other one I'm very familiar with is POD and that would be a real pain in the ass to get into the parser to handle things correctly.

A place for all your stuff

coyled@coyled.com (Dave Coyle) — Sat, 08 May 2010 14:31:30 -0400

Okay, I'm anticipating a few users coming here that may have written neat little functions and things in Farnsworth. And I'd love for you guys to show off the snippets you've written. I'm going to do another article here in a bit about some changes I made last night to the latest WIP version of Farnsworth that let you do neat things with lambdas and unit conversions that'll let more things work in as natural a fashion as possible. So come show off your snippets!

Google Groups

coyled@coyled.com (Dave Coyle) — Fri, 07 May 2010 03:30:12 -0400

I've gone and opened up a google group for the development of the language, come join us if you'd like to follow things. At the moment it'll be fairly sparse considering i'm the only developer, and the only member of the list too. http://groups.google.com/group/farnsworth-dev

Language::Farnsworth::Functions::GoogleTranslate v0.9.1

coyled@coyled.com (Dave Coyle) — Sat, 01 May 2010 22:47:56 -0400

I've just uploaded a new copy of Language::Farnsworth::Functions::GoogleTranslate to cpan, this update brings in a few more languages such as Yiddish, HatianCreole, Welsh, Afrikaans and a few others that weren't supported by the last release. Not a lot else to say about this release, no bugs fixed (i'm not aware of any) and no new features (I have some plans but haven't even come close to thinking about how to make it work right). I've been mulling over an idea about how to make what amounts to a set of paths for doing translations with multiple services but haven't come up with a good idea on how to design it all yet.

Dirty Hungarian Dictionaries

coyled@coyled.com (Dave Coyle) — Fri, 30 Apr 2010 02:21:04 -0400

Language::Farnsworth::Functions::GoogleTranslate has been spun off into its own dist on cpan, i've done that simply because it won't be updated except to add new languages for the time being. (unless i break it, or make a proper plugin system). So if you're wanting to use those nice fancy translation features, you'll want to install it also, and for those of you who are wondering i'll also provide here a copy of the string mangling function that the bot uses.

{``
var steps = [];
var languages = ["Arabic","Bulgarian","Catalan","Czech","Danish","German",
"Greek","English","Spanish","Estonian","Finnish","French","Galician","Hindi",
"Croatian","Hungarian","Indonesian","Italian","Hebrew","Japanese","Korean",
"Lithuanian","Latvian","Maltese","Dutch","Norwegian","Polish","Portuguese",
"Romanian","Russian","Slovak","Slovenian","Albanian","Serbian","Swedish",
"Thai","Filipino","Turkish","Ukrainian","Vietnamese","Chinese","Chinese_Traditional"];

var getlang = {`` languages@random[]*(length[languages])$};

mangle{x} := {steps = [];
              var origlang = x -> DetectLanguage;
              push[steps, x];
              var targetlangs = int[random[]*42]+1;

          while (targetlangs=targetlangs-1)
          {
            push[steps, eval["steps@-1$ -&gt; "+getlang[]]];
          };

          push[steps, eval["steps@-1$ -&gt; "+origlang]];
          steps@-1$};


tracemangle{} := {steps};

} []; /this bit makes the lambda we just finished making get executed rather than storing it somewhere/

What's going on in it is that we've got two main variables that we don't really want to expose to the world, for pollution and protection reasons (a bit like using an object!). So what we do is we make a lambda since it has its own scope and define everything inside of it, event the functions that are exposed to the outside world by virtue of going into the function namespace.

Even though they're accessible to the world they still live inside the scope of the original lambda allowing them to use the two variables steps, languages and getlang. languages should be fairly self explanatory, its a list of all the languages that the google translate library supports. getlang is a little harder but still somewhat easy to figure out, its a lambda that gets a random language from the languages variable. steps is a little strange, we store each and every result that we get from google translate so that we can later examine them with the tracemangle[] function (i.e. to figure out where it got "purple monkey dishwasher" from).

The two functions it exports out to the world, tracemangle[] and mangle[] are pretty simple to understand. tracemangle[] is just a simple getter for the internal steps variable.

mangle[] starts by clearing the last steps we took, and then by using the DetectLanguage[] function provided by the translation library to find out what language we're starting with, this will be used later on. After that we pick a random number of languages to translate to (we use the 42 simply because it seems to work well when played with, other values work fine but well 42...). Then we go into a fairly simple while loop (the language still does not have any for loops, which will be recitfied) that uses the eval[] function to create and run a simple snippet of code that looks something like:

steps@-1$ -> Japanese

The reason we use the variable steps is that it helps prevent someone from inserting their own code to be run. We do this until we've done the requisite number of translations that we decided on before, and then we do ONE more translation. This time we go and do a translation into the original source language found from DetectLanguage[]. This allows us to mangle things from any language into any language and makes a few of the Dutch people that use the bot happy.

New release being prepared, 0.7.2

coyled@coyled.com (Dave Coyle) — Mon, 26 Apr 2010 20:05:58 -0400

I'm getting ready to upload a new version of farnsworth, 0.7.2 to CPAN, it contains a fix in the parser for equations like 2a**2 correctly parsing as 2 * (a ** 2) and more like it. This fixes the last known issue with the parser and makes me very happy. I'll be working on 0.7.3 after exams and it should contain mostly only documenation updates and fixes. (there is also experimental support for a new lambda syntax in the same vein as ruby, e.g. {|x| x**2}, i don't know if it'll stay or not but it'd be nice to get the backticks back for other uses.) EDIT: apparently i missed something when adding the alternate syntax lambda support, so its not correctly in there and doesn't work, i did say it was experimental didn't i?

Farnsworth

coyled@coyled.com (Dave Coyle) — Mon, 26 Apr 2010 12:00:46 -0400

Ok, now that I've got things setup here I plan on using this place for keeping track of what's going on in the Farnsworth community (i.e. me, there's only me right now). I'll be making official announcements and posts about the current state of what I'm working on in the interpreter. (since this is also a personal page for myself i'll also eventually have a copy of my resume and everything else here but that'll come a bit later), here's hoping that things turn out well.