|
Self Programming Language Directory @ eIT.in
eIT.in – everything IT is in Here eIT Directory
|
|
Hot & Cool
Serkai – The Web Cooperative
AntiSE – The Anti Search Engine
GeoDig – Businesses by Geography
Quali5 – Own a Keyword Forever
Follars – Making Money from Open Source
Billion Dollar Questions – and answers @ Billdoll.com
The Anti Bush Register – sign the register now! Advt |
|
eIT.in – 100’s of categories, 1000’s of IT resources
|
|
Operating Systems, Programming & Development, Databases, Legacy & Mainframe, Internet |
|
Computer hardware and accessories, performance & maintenance, storage… |
|
Networking architecture, infrastructure, administration, standards & protocols…
|
|
ITIL, IT infrastructure management…
|
|
Information technology & software support, administration, software testing, data centers…
|
|
Information technology & software across industries
|
|
Information technology & software across functional domains
|
|
IT Organizations & Industry Network
IT associations & organizations, IT related directories and trade networks…(Software Links Exchange)
|
|
Information technology & software architecture and design, IT strategy
|
|
IT news, updates, events & trade shows |
|
|
|
Related Links
Mainframes (Mainframe), AML, Analytics, Databases, EAI, BPO, CRM, Legacy, Legacy 2 Web, Middleware, IT Software Outsourcing & Offshoring Directory, Follars
|
|
Self Programming Directory @ eIT.in
This section of eIT.in provides web resources for Self programming language.
Add Links: If you have a web site that you wish to include in this database, do let us know the details by sending a note about your URL to narsi@esource.in. We’ll quickly review the web site, and if found relevant, add it to the database. We look forward to web site owners and link exchange partners to submit URL. Thanks!
..
..
Other IT Web Sites from eIT.in
Content derived from Wikipedia article on Self Programming Language
Self (programming language) From Wikipedia, the free encyclopedia
This article or section does not cite its references or sources. You can help Wikipedia by introducing appropriate citations.Self Paradigm: multi-paradigm: object-oriented, prototype-oriented Appeared in: 1986 Designed by: David Ungar & Randall Smith Developer: David Ungar, Randall Smith, Stanford University, and Sun Microsystems Typing discipline: dynamic, strong Major implementations: Self Influenced by: Smalltalk Influenced: NewtonScript, JavaScript, Io, Cel, and Agora.
Self is an object-oriented programming language based on the concept of prototypes. It was used primarily as an experimental test system for language design in the 1980s and 1990s; however, as of July of 2006, Self is still being actively developed as part of the Klein project which is a Self virtual machine written entirely in Self. The last major version is 4.3, which was released in July 2006.
Contents
1 History 2 The problem 3 The solution 4 The language 5 Basic syntax 6 Making new objects 7 Inheritance 8 Adding slots 9 The environment 10 External links 11 See also
History Self was designed primarily by David Ungar and Randall Smith in 1986 while working at Xerox PARC. Their objective was to push forward the state of the art in object-oriented programming language research, once Smalltalk-80 had gone out of the labs and began to be taken seriously by the industry. They moved to Stanford University and continued work on the language, building the first working compiler in 1987. At that point focus changed to attempting to bring up an entire system for Self, as opposed to just the language.
The first public release was in 1990, and the next year the team moved to Sun Microsystems where they continued work on the language. Several new releases followed until falling largely dormant in 1995 with the 4.0 version. The latest 4.2 version was released in 2004 and runs on Mac OS X and Solaris.
Self also inspired a number of languages based on its concepts. Most notable, perhaps, was the NewtonScript language for the Apple Newton and the JavaScript language used primarily for dynamic web pages in all modern browsers. Other examples include Io, Cel and Agora.
The problem Traditional object languages are based on a deep-rooted duality. Classes define the basic qualities and behaviours of objects, and instances are a particular object based on a class.
For instance, one might have a Vehicle class that has a "name" and the ability to perform "drive to work" and "deliver construction materials". Porsche 911 is a particular instance of the class Vehicle with the name set to "Porsche 911". In theory one can then send a message to Porsche 911, telling it to "deliver construction materials".
This example shows one of the problems with this approach. A Porsche is not able to carry and deliver construction materials (in any general sense anyway!) but this is something that a vehicle can do. To avoid this problem, we must add additional specialization to Vehicle via creating subclasses. In this case, one can imagine "sports car" and "flatbed truck".
This is a contrived example, but illustrates a very real problem. Unless one can predict with certainty what qualities the objects will have in the distant future, one cannot design a class hierarchy properly. All too often the program would eventually need added behaviours, and the whole system (or rather sections of it) need to be re-designed (or refactored) to break out the objects in a different way.
Experience with early OO languages like Smalltalk showed that this sort of issue came up again and again. Systems would tend to grow to a point and then become very rigid, as the basic classes deep below the programmer's code grew to be simply "wrong". Without some way to easily change the original class, serious problems could arise.
Dynamic languages such as Smalltalk allowed for this sort of change via well-known methods in the classes; by changing the class, the objects based on it would change their behaviour. But in other languages like C++ no such ability exists, and making such changes can actually break other code, a problem known as the fragile base class problem. In general, such changes had to be done very carefully, as other objects based on the same class might be expecting this "wrong" behavior: "wrong" is often dependent on the context.
The solution The problem here is that there is a duality, classes and instances. Self simply eliminated this duality.
Instead of having an "instance" of an object that is based on some "class", in Self you make a copy of an existing object, and change it. So "Porsche 911" would be created by making a copy of an existing "Vehicle" object, and then adding the "drive to work" method. Basic objects that were used primarily to make copies of were known as prototypes.
This may not sound earth shattering, but in fact it greatly simplifies dynamism. If you have to fix a problem in some "base class" because your program has a problem, simply change it and make copies of that new object instead. No other program will see this change. If at some point in the future Porsches can "deliver construction materials", you can just add the appropriate method.
This dramatically simplifies the entire OO concept as well. Everything might be an object in traditional system, but there is a very fundamental difference between classes and instances. In Self, there isn't.
The language Self objects are a collection of "slots". Slots are accessor methods that return values, and placing a colon after the name of a slot sets the value. For instance if you have a slot called "name",
myPerson name returns the value in name, and
myPerson name:'gizifa' sets it.
Self, like Smalltalk, uses blocks for flow control and other duties. Methods are objects containing code in addition to slots (which they use for arguments and temporary values), and can be placed in a Self slot just like any other object: a number for instance. The syntax remains the same in either case.
Note that there is no distinction in Self between fields and methods: everything is a slot. Since accessing slots via messages forms the majority of the syntax in Self, many messages are sent to "self", and the "self" can be left off (hence the name).
Basic syntax The syntax for talking to slots is Smalltalk-like. Three kinds of messages are available:
unary receiver slot_name binary receiver + argument keyword receiver keyword: arg1 With: arg2 All messages return results, so the receiver (if present, otherwise "self is implied") and arguments can be themselves messages. Following a message by a period means you want to discard the returned value. For instance:
'Hello, World!' print. This is the Self version of the hello world program. The ' syntax indicates a literal string object. Other literals include numbers, blocks and general objects.
Grouping can be forced by using parentheses. In the absence of explicit grouping, the unary messages are considered to have the highest precedence followed by binary (grouping left to right) and the keywords having the lowest. The use of keywords for assignment would lead to some extra parenthesis where expressions also had keyword messages, so to avoid that Self defines the first part of the keyword to start with lower case and all the rest with upper case letters. So:
valid: base bottom between: ligature bottom + height And: base top / scale factor. This has exactly the same meaning as:
valid: ((base bottom) between: ((ligature bottom) + height) And: ((base top) / (scale factor))). In Smalltalk-80, the same expression would look like:
valid := self base bottom between: self ligature bottom + self height and: self base top / self scale factor.
Making new objects Consider a slightly more complex example:
labelWidget copy label: 'Hello, World!'. makes a copy of the "labelWidget" object with the copy message (no shortcut this time), then sends it a message to put "Hello, World" into the slot called "label". Now let's do something with it:
(desktop activeWindow) draw: (labelWidget copy label: 'Hello, World!'). In this case the (desktop activeWindow) is performed first, returning the active window from the list of windows that the desktop object knows about. Next (read inner to outer, left to right) the code we examined earlier returns the labelWidget. Finally the widget is sent into the draw slot of the active window.
Inheritance In theory, every Self object is a stand-alone entity. There are no classes, meta-classes and so on to help it do its job. Changes to this object don't affect any other, but in some cases it would be nice if they did. Normally an object can understand only messages corresponding to its local slots, but by having one or more slots indicating parent objects the object can delegate any message it doesn't understand itself to them. Any slot can be made a parent pointer by adding an asterisk as a suffix. In this way Self handles duties that would use inheritance in more traditional languages. It is also used to implement name spaces and lexical scoping.
For instance, you might have an object defined called "bank account" that is used in a simple book keeping application. Typically this object would be created with the methods inside, perhaps "deposit" and "withdraw", and any data slots needed by them. This is a prototype, which is only special in the way it is used since it also happens to be a fully functional bank account.
Making a clone of this object for "Bob's account" will create a new object which start out exactly like the prototype. In this case we have copied the slots including the methods and any data. However a more common solution is to first make a more simple object called a traits object which contains the items that one would normally associate with a class.
In this example the "bank account" object would not have the deposit and withdraw method, but would have as a parent an object that did. In this way many copies of the bank account object can be made, but we can still change the behaviour of them all by changing the slots in that root object.
How is this any different from a traditional class? Well consider the meaning of:
myObject parent: someOtherObject. This is quite interesting, it changes the "class" of myObject at runtime by changing the value associated with the 'parent*' slot (the asterisk is part of the slot name, but not the corresponding messages).
Adding slots How can copied objects in Self be modified to include new slots? Using the graphical programming environment, this is very easy. Programmatically, the proper way to do it is to create a mirror object reflecting the one that will be modified and then send a series of messages to that mirror.
A more direct way is to use the primitive '_AddSlots:'. A primitive has the same syntax as a normal keyword message, but its name starts with the underscore character. The _AddSlots primitive should be avoided because it is a left over from early implementations. However, we will show it in the example below because it makes the code shorter.
An earlier example was about refactoring a simple class called Vehicle in order to be able to differentiate the behaviour between cars and trucks. In Self one would accomplish this something like this:
_AddSlots: (| vehicle <- (|parent* = traits clonable|) |). Since the receiver of the '_AddSlots:' primitive isn't indicated, it is "self". In the case of expressions typed at the prompt, that is an object called the "lobby". The argument for '_AddSlots:' is the object whose slots will be copied over to the receiver. In this case it is a literal object with exactly one slot. The slot's name is 'vehicle' and its value is another literal object. The "<-" notation implies a second slot called 'vehicle:' which can be used to change the first slot's value.
The "=" indicates a constant slot, so there is no corresponding 'parent:'. The literal object that is the initial value of 'vehicle' includes a single slot so it can understand messages related to cloning. A truly empty object, indicated as (| |) or more simply as (), cannot receive any messages at all.
vehicle _AddSlots: (| name <- 'automobile'|). Here the receiver is the previous object, which now will include 'name' and 'name:' slots in addition to 'parent*'.
_AddSlots: (| sportsCar <- vehicle copy |). sportsCar _AddSlots: (| driveToWork = (some code, this is a method) |). Though previously 'vehicle' and 'sportsCar' were exactly alike, now the latter includes a new slot with a method that the original doesn't have. Methods can only be included in constant slots.
_AddSlots: (| porsche911 <- sportsCar copy |). porsche911 name:'Bobs Porsche'. The new object 'porsche911' started out exactly like 'sportsCar', but the last message changed the value of its 'name' slot. Note that both still have exactly the same slots even though one of them has a different value.
The environment Perhaps one of Self's few problems is that it is based on the same sort of virtual machine system that earlier Smalltalk systems used. That is, programs are not stand-alone entities as they are in languages such as C, but need their entire memory environment in order to run. This requires applications to be shipped in chunks of saved memory known as snapshots which tend to be large and annoying to use. [citation needed]
On the upside, the Self environment is very powerful. You can stop programs at any point, change values and code, and continue running where you left off. This sort of "on the fly" development delivers a huge increase in productivity. [citation needed]
In addition the environment is tailored to the rapid and continual change of the objects in the system. Refactoring a "class" design is as easy as dragging methods out of the existing ancestors into new ones. Simple tasks like test methods can be handled by making a copy, dragging the method into the copy, then changing it. Unlike traditional systems, only the changed object has the new code, and nothing has to be rebuilt in order to test it. If the method works, it can simply be dragged back into the ancestor.
External links Self Home Page at Sun Microsystems Papers on Self from UCSB (mirror for the Sun papers page) Self resources at Cetus Links Merlin Project Self ported to Linux (without many optimizations) Automated Refactoring application on sourceforge.net, written for and in Self Gordon's Page on Self Prometheus object system on the Community Scheme Wiki
See also Cecil programming language Smalltalk programming language Io programming language Retrieved from "http://en.wikipedia.org/wiki/Self_%28programming_language%29"
End of Wikipedia content, http://en.wikipedia.org/wiki/Self_programming_language
Web Resources for Self Programming Language
|
|
More eIT.in References
§ The A-Z of Programming Languages § A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z § S · S · Sed · Sail · SAS · Sather · Scheme · SDL · Self · SETL · Sh · Simula · Sisal · Snobol · SR
Main Sections @ eIT.in
o Mainframe & Legacy Operating Systems · Midrange · Programming & Development Directory § The A-Z of Programming Languages § A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P, Q, R, S, T, U, V, W, X, Y, Z
|
|
About eIT.in
eIT.in is a comprehensive directory for everything IT & Software. It contains over 500 categories, and well over 10,000 web resources
eIT.in provides directory and web links resources for the IT, software, programming & software development domains. It is intended to be useful for application, applications programmers & developers, software technology programmer & developer, databases software development, administrators & DBAs, application developers, strategy architect, design specialists and architects, migration, integration, customization consultants and customisation analysts, administration, maintenance & support professionals, outsourcing consultant, bespoke solutions programming developers & coders, project management & functional analyst, and for system administrators, testing & quality control engineers. It will make an effort to provide resources on tutorial/tutorials, guide, guides, tips, faq, faqs on these topics.
eIT.in content is available under GPL: All directory content at mainframe.in is under the General Public License (GPL). Under this license, anyone is free to copy & use any amount of directory content @ eIT.in, make changes to it and use it in any way they wish, as long as they also allow the same rights to anyone else for this content. The concept of GPL has been adapted from the GNU GPL of the Free Software Movement. To those who wish to use content from eIT.in, our only request is that they acknowledge the source and provide a link back to eIT.in. This is only a request!
Countries & Cities Where eIT.in Provides Assistance
eIT Cities: Bangalore, Chennai, Mumbai, Bhubaneswar, Mysore, Kolkaka, Delhi, Pune, Trivandrum, Hyderabad
You are the $$$ Section of eIT.in
Reference
GeoDig – Get Local!
Have you checked out the GeoDig directories for over 30 countries? GeoDig provides useful local and regional web resources for over 200 cities around the world. See the list of cities and countries for which GeoDig provides locality-specific web resources.
North America USA - Alabama (AL) > Birmingham; Alaska; Arkansas (AR) > Little Rock; Arizona (AZ) > Phoenix, Las Vegas, Tucson; California (CA) > Los Angeles, San Francisco, Sacramento, Fresno, Bakersfield; Colorado, CO > Denver; Connecticut, CT > Hartford; District of Columbia, DC > Washington DC; Delaware (DE) > Wilmington; Florida > Miami, Orlando, Tampa, Orlando, Sarasota, West Palm Beach, Jacksonville; Georgia > Atlanta; Hawaii > Honolulu; Idaho; Illinois > Chicago; Indiana > Indianapolis; Iowa; Kansas (KS); Kentucky (KY) > Louisville; Louisiana (LA) > New Orleans, Baton Rouge; Maine; Maryland (MD) > Baltimore; Massachusetts > Boston, Springfield; Michigan > Detroit, Grand Rapids; Minnesota > Minneapolis-St. Paul; Mississippi (MS); Missouri (MO) > Kansas City, St. Louis; Montana; Nebraska (NE) > Omaha; Nevada (NV) > Las Vegas; New Hampshire; New Jersey (NJ) > Jersey City, Newark; New Mexico (NM) > Albuquerque; New York > New York, Buffalo, Rochester, Albany, Syracuse; North Carolina (NC) > Raleigh-Durham, Charlotte, Greensboro; North Dakota; Ohio> Columbus, Cincinnati, Cleveland, Toledo, Youngstown, Dayton; Oklahoma (OK) > Oklahoma City, Tulsa; Oregon > Portland; Pennsylvania > Philadelphia, Allentown, Pittsburgh, Harrisburg, Scranton, ; Rhode Island (RI) > Providence; South Carolina (SC) > Greenville; South Dakota; Tennessee (TN) > Knoxville, Memphis, Nashville; Texas > Austin, Dallas, Houston, San Antonio, El Paso, Austin, McAllen; Utah (UT) > Salt Lake City; Vermont; Virginia (VA) > Norfolk, Richmond; Washington > Seattle; West Virginia; Wisconsin (WI) > Milwaukee; Wyoming Canada - Vancouver, Montreal, Toronto, Calgary, Ottawa-Gatineau, Edmonton, Quebec City, Winnipeg, Hamilton, London
You are the $$$ Section of eIT.in
Europe - UK - London, Glasgow, Manchester, Birmingham, Liverpool, Sheffield, Leeds, Bristol, Edinburgh, Leicester; France - Paris, Marseille, Lyon, Toulouse, Nice, Nantes, Strasbourg, Montpellier, Bordeaux; Germany - Frankfurt (Frankfurt am Main), Munich (München), Berlin, Düsseldorf, Hamburg, Cologne (Köln), Essen, Dortmund, Stuttgart, Bremen, Duisburg, Hannover, Nürnberg (Nuremberg), Dresden, Leipzig; Italy - Milan (Milano), Rome (Roma), Napoli (Naples), Torino (Turin), Palermo, Bologna, Firenze (Florence), Genova (Genoa); Spain - Madrid, Barcelona, Valencia, Sevilla, Zaragoza, Malaga, Murcia, Las Palmas, Bilbao; Scandinavia - Finland - Helsinki (Helsingin), Espoo, Tampere (Tampereen), Vantaa, Turku, Oulu, Sweden - Stockholm, Goteborg (Göteborg), Malmo (Malmö), Uppsala, Vasteras (Västerås), Denmark - Copenhagen (Københavns), Aarhus (Århus), Odense, Aalborg (Ålborg), Norway - Oslo, Bergen, Stavanger, Trondheim; Benelux - Belgium - Brussels (Brussel), Antwerp (Antwerpen), Ghent (Gent, Gand), Charleroi, Liège (Liege), Netherlands - Amsterdam, Rotterdam, Utrecht, Eindhoven, Tilburg, ‘s-Gravenhage (sGravenhage), Groningen, Luxembourg - Luxembourg City; Portugal – Lisbon; Greece – Athens; Hungary – Budapest; Poland – Warsaw; Switzerland - Zürich (Zurich), Geneva (Geneve, Genève), Basel, Bern (Berne), Lausanne; Austria - Linz, Vienna (Wien), Graz, Linz, Salzburg, Innsbruck; Ireland – Dublin
Asia - India - Mumbai, New Delhi, Bangalore; China & Hong Kong - Hong Kong, Beijing, Shanghai, Tianjin, Wuhan, Shenyang, Guangzhou, Harbin, Xian; Japan - Tokyo, Osaka, Yokohama, Nagoya, Sapporo, Kyoto, Kobe, Fukuoka, Kawasaki, Hiroshima; South Korea - Seoul, Pusa, Taegu, Incheon, Taejeon, Taiwan - Taipei; Malaysia - Kuala Lumpur; Singapore; Russia - Moscow, St Petersburg
You are the $$$ Section of eIT.in
Middle East - Turkey - Istanbul, Israel - Tel Aviv
Oceania - Australia - Sydney, Melbourne, Brisbane, Perth, Adelaide
Africa - South Africa - Johannesburg, Cape Town, Durban
|
|
© 2006, From eIT.in – everything IT is in Here
eIT.in is a product of eSource India & Sourcing India
Other eSource & Sourcing sites: IT & Software (Dir, SAP), BPO, Chemicals, Textiles, Plant Oils, dotMobi, Billion Dollar Questions, Biodiesel Encyclopedia, Linens, ideOS, Follars – Free, Open-source Dollars, Quali5.com – Own A Keyword Forever, AntiSE, Serkai, Leather & Hide, GeoDig
|