Yankee's Psycho Programing Semantics

my crazy clipboard idea

2005-08-15T06:05:26Z

Ok, so this will be an addition to my object oriented operating system addiction:

So assuming we have some GUI system that is designed from a proper OO sense, we can assume that any time data is sent to the clipboard, some clipboard event is generated. And as follows, a ClipboardEventListener (to use the Java phraseology tonight) recieves this event. (Multiple listeners can recieve it too, as long as they don't conflict later on, and we'll see why). Our obvious standard clipboard listener would take the data, parse the datatype and interfaces using some element of the API, and generate some stub such that any other object/application can request a reference/copy of that stub containing the data and any possible metadata. It would put that into a single memory space, overwrite the old one, etc...
Now there are many re-implementations of the clipboard. Microsoft uses a kludge within the MS Office framework where it maintains a limited history of the clipboard. Gnome and KDE use a subtle kludge on top of the X Windows clipboard making it slightly more user friendly. KDE even has a klipper tool that maintains a user configurable history.
What if we were to do away with all these kludges? First, I propose that we have the option of passing a setClipboardEventListener/addClipboardEventListener message to the windowing system with rules on what permissions an object would require to arbitrarily reconfigure the clipboard. And how do old clipboards communicate with new ones what to do with their clipboard histories?
Secondly, I propose justification for bending over in this mental kama sutra. I am doing some data entry work that requires massive amounts of copying and pasting. I will take little bits of data from many files that I want in a list as one file. If i had the ability, I would write a simple plugin to give me a new clipboard mode. Everything I copy is stacked one by one on the clipboard in a Queue+Stack of arbitrary length. I could then have my clipboard object register shortcuts to my environment that let me pop items off either the Queue, Stack, or anywhere in the middle. If this were emacs, I might type something like C-v 35th and have the 35 item pasted.
Anyways, those are my two cents on something totally trivial and pointless. G'night all.

Lambda Datatypes and Aspect Classes

2005-06-28T05:22:34Z

Time for another post. I have work in the morning, so mainly I'm going to address a comment on my first post. I also have an idea thats completely incomplete, and I'm tired enough to not want to solve it now.
Its a fairly simple idea with many complex reprecussions. One element of Object Oriented Programming is Inheritance. Some languages allow you to inherit from only one class, and some allow you to inherit from more than one class. Dual inheritance is not a problem until you consider what happens when both super classes share a common super class. Both classes are initializing the same base class, and no one knows which one is dominant or passive, and how to keep both classes from changing the base class in ways that are incompatible with each other.
(I apologize for the confusion those last few sentences have; this is a common CS problem, and I'm too tired to explain in detail now. Just ask for a better explanation if you don't fully understand)
For those familiar with Aspect Oriented Programming, this might make alot of sense. First some background however. I have been working on a small framework for some very simple IRC bots. There is a simple base class that all IRC bots have, that already contain the code to make a connection to an IRC server, stay connected, join and part channels, and optionally execute arbitrary code for debugging purposes. I then came up with several tasks or aspects a bot might want to perform, tasks such as randomly saying thing, quotes, phrases, single words, logging the chat and compiling statistics, or providing authentication for operator status. (This server doesn't have any service bots.) I want to be able to create aspect classes that a Rabid Developer (my nickname for programmers who uses lots of premade code and glue it together to create all sorts of complex programs) can take to mix and match the different pieces he needs. These would be classes that have limited functionality, such that they can only touch the base class in specific predescribed ways. The Aspects would need to be written by the base class developer and by no one else, so that he(they) can ensure they are all compatible with each other, or at least document which ones don't work with which other ones. Other than this, I have this mental block trying to figure out what some of these rules should be.
Now here is the part where we answer a few of your letters.
Nightstrike9809 wrote: Its a truly interesting idea but I feel I am missing the true point of this, how would you implement Lambda Datatypes?
This is no different than template functions in C++. However, from a semantical point of view (and not necessarily that of the compiler) I am thinking of creating an Interface to borrow a term from java for a Function<...> that can have any number of generic data types, but is forced into using it. There would then be a required method __func__(...) that could take any number of parameters (possibly defined by the generic datatype decleration) and to borrow from python, this would make all objects implementing this interface "callable" and capable of being passed arguments, returning arguments, etc....
You can figure how badly you want to kludge your language's syntax from here.
As to why I would want to torture myself to provide such odd functionality, its the same argument as using templates/generics in the first place. From my academic high point, I feel that the compiler should spot as many errors first, which translates into better syntax error detection on the IDE's behalf as well. Anyone familiar with Eclipse should understand how much this can be a help (or hinderance). The basic idea works like this though. I have my callback function. When its called, its called with arbitrary data some other programmer in my project team passed to me. I want a garauntee that this chunk of data implements methods X, Y, and Z. By using generics, I can tell this peer of mine, I will only accept objects that implement these methods. When I pass the callback to the connect method of a widget, I might pass it like this:

widget.connect<String>(some_callback, "From John")

void some_callback<D implements String>(Widget widget, D data) {
other_string = data + " with love";
}

Thats it for now, I'm tired, Good night.

First Entry | Lambda Datatypes

2005-06-04T05:50:20Z

Lately I have had a lot of interesting ideas for computer programming, and I finally decided, I should keep a journal of my ideas to share them with others and so that they can give me feedback on it. If I get good at keeping this thing up to date, I might even write a more personal friends only journal.

To give you hopefully faithful readers an idea of where this is coming from, my name is Yaakov, and I am a Computer Science and Engineering major at the University of Connecticut, which, if you haven't figured it out, means I live in the US. Hence, I make no apologies. Although I have known the fundamentals of programming since i was nine, I have only recently in the past year and half began taking programming seriously and wanted to explore more than just the BASIC material I have known till now. (Pun Intended). Most of my ideas involve creating a flexible language similar to Python or the POSIX Shell, that is also robust like Java, C#, and Objective-C, and (you can start laughing) low level enough for an operating system to be written in it. Simply put, one Operating System, One Language, One set of commands to memorize, and One ring to bind them all. (There will be room for other languages, and I will probably write more on this later, so save your flames for then. Thank you.) In the past year I've been programming in Java, and my first set of posts will most likely take a slant in that direction. Such as this one.

Onto the goal of this post. My current language of choice is Python. I've been using it for one of its common descriptions. It's a convenient glue between many different programs and libraries on my computer. It's designed around the whole 'nix structure so most of what is available to me is integrated very nicely. However, one thing has been pissing me off tremendously. Java is incredibly strict about its data types; so strict that I am garaunteed the second my fingers touch the keyboard what methods are available on the data that I am working on. Python can't do that. I don't blame it; I think it is a fine language in how and what it implements and why it implements it as such. This won't meet my goals. Compile time checking is as important to me as Garbage Collection. It ensures certain basic things programmers take for granted will work as intended without wasting programmer effort keeping track of many details. I'd love to hear about good uses for run time checking, but other than the case I will discuss later, I don't know of too many cases where I wasn't banging my head against the screen in frustration with python.

Abstract
The following proposition is intended to create a consistent structure that gives the programmer some of the benefits of Python's weaker data type declaration system without sacrificing compile time error checking. I will discuss one specific case now that I've run into with the pygtk libraries, and save the more general purpose for discussion later. This idea is also incomplete as of now.

Background
Some Object Oriented languages that require strict type declaration implement some system of template classes that can be compiled multiple times, each time handling a different data type. Java's system is a favorite of mine. Not only is it incredibly consistent and the compiler issues are hidden very well from the programmer (unlike in C++), it even lets you create a contract saying that all data types must implement a certain interface (i.e. a certain set of methods). Furthermore, some languages that implement procedural functions (such as C++) also implement templates for said procedural functions.

Theory
At a cursory glance, Python has many structures simiilar to C++ and Java that appear as if they could be controlled with better type declaration. Certain aspects (methods like __ge__(x)) could be moderated into a set of interfaces such as Numerical and StringLike (suggestions are open for better names). However in my discovery of the pygtk libraries and its implementations of signals I found a case that would be difficult to enforce strong typing. I will assume the reader is familiar with signals and event based programming. (If I get many requests going "Huh?" or the like, I'll put up an entry explaining this.) I can create a callback function with the signature:

callback(widget, data)

where data can be any arbitrary data that can be passed from the widget emiting the signal. This data is usually specified when connecting the signal to the emiter using the signature:

widget.connect(callback, random_data)

and random_data could be any type. In Java, this random data would have been passed as type Object which is the supreme ancestor data type for any class. However, inside the callback function, I would have to typecast this Object into my desired data type which results in run time checking. Queue templates, for the same reason Java 5 introduced them. Only this time, the templates apply to the method. I have a connect signature like so:

widget.connect<D>(CallBack callback<D>, D random_data)

and the callback is:

callback<D>(Widget widget, D data)

Simply put, our class methods can create their own arbitrary data types seperate from the template data types they are already working with. There is an obvious responsibility for programmer to keep the template names from colliding because our methods obviously inherit the template type namespace from their class. If I have the type T floating around already, my new type can't be called T, though D is a valid name. I call these Lambda datatypes because in terms of creating lambda functions, we are creating lambda functions that take a datatype as a parameter and return a function or class specific to that datatype. Obviously the overhead in treating it that way means the compiler will do things differently, but the concept is the same.
--fin--