OpenEuphoria

1. Prototype-Based Programming

• Posted by TheresNoTime Sep 25, 2013
• 2402 views

I saw in the Archive several extensions, which injected OOP to Euphoria. However, the creators of Euphoria, apparently, are the enemies of this paradigm. So I'm not sure OOP appears in the fifth version. So, what about Prototype-Based Programming? AFAIK, it is easier to implement, easier to grasp, easier to code.

http://en.wikipedia.org/wiki/Prototype-based_programming

3. Re: Prototype-Based Programming

• Posted by TheresNoTime Sep 25, 2013
• 2313 views

I myself is not a OOP-fan[atic]. On the contrary, this paradigm is alien to me. But how else to develop a program consisting of several large pieces? In principle, it is possible to realize the communication between parts in pure Euphoria (stuffing maps in the stack). But it is the invention of bicycles.

Even so, I can not wait. I have three ways:
1. Add one of the OOP-extensions in the Euphoria. The main drawback of this approach: I do not know what extension to choose. And all of a sudden it will not work?
2. Choose mainstream OOP-language such as C#.
3. Find another way of splitting the program into parts. For example, dissect it to independent programs that communicate through files (in 21th century!).

Unfortunately, I can provide such information only in Russian. Search about what's inside the PBP in JavaScript, Lua or other PBP-language. In short, the PBP is programming with objects, but without classes. Each object is unique. Thus, we can not inherit classes (because they are not). It's not so bad. Many believe that the inheritance is the evil. In the GO language (by Google!) no inheritance. As far as I know, this is called "anemic OOP". (But I'm not sure I understand correctly this term.) This is not the first example, where the improvement is to avoid something. For example, the avoid of the operator GOTO improves the structure of the programs. So, what we have instead of inheritance? Cloning! We can clone any object. It is possible to do in almost any language, that have some structure, which capable to store data and pointers (routine_id). For example, PBP in Lua is just syntactic sugar for it's tables.

5. Re: Prototype-Based Programming

• Posted by useless_ Sep 25, 2013
• 2264 views

Didn't Karl do OOP for Eu in Russian? Check archives. Matt did Eu OOP too, but it slowed to a stop eventually. I am not a fan for OOP either, but i did write posts supporting Matt's version of OOP for Eu.

useless

7. Re: Prototype-Based Programming

• Posted by EUWX Sep 25, 2013
• 2345 views

According to the URL supplied: "Prototype-based programming is a style of object-oriented programming".

I thoroughly dislike OOP. I agree with the following:-

"Paul Graham has suggested that the purpose of OOP is to act as a "herding mechanism" that keeps mediocre programmers in mediocre organizations from "doing too much damage". This is at the expense of slowing down productive programmers who know how to use more powerful and more compact techniques.".... source wikipaedia.

http://www.paulgraham.com/noop.html

9. Re: Prototype-Based Programming

• Posted by EUWX Sep 25, 2013
• 2311 views

"You should be able to define new types, but you shouldn't have to express every program as the definition of new types."
Well I like, symmetrical matrices i.e. matrices with same shape throughout (2 and 3 dimensions filled fully); I can define them once and use the same code to define in all my programs.
In short, oop is not useful at all.

11. Re: Prototype-Based Programming

• Posted by jimcbrown (admin) Sep 25, 2013
• 2260 views

Actually, though it's possible I'm misunderstanding or something, this appears to make sense to me.

Basically, using the example of custom matrices, OP points out that OP can make new types without having to resort to OOP to do it. In other words, OOP is not necessary even if you want to be able to define new types - so that's one OOP-only use case that can be crossed off the list. Or something like that, anyways.

13. Re: Prototype-Based Programming

• Posted by TheresNoTime Sep 25, 2013
• 2288 views

Yes, OOP isn't silver bullet. There are other techniques. Lisp is functional language. Component Pascal (created by OOP-hater Niklaus Wirth) is component-oriented. The most understandable explanation of component paradigm (if you familiar with .NET a bit, like me). Imagine that you have made several class libraries (possibly in different languages) and compiled them in a separate DLLs. Then you glue them using PowerShell. But how to glue DLLs writed in Euphoria? Get and send parameters by win32lib? Thanks, but I know easier ways to commit suicide.

Euphoria is pure (poor) procedural language. I started the program in Euphoria, it was very simple, but now simplicity prevent me to continue. Erlang based on unique paradigm, where each part of program is independent process (with it's own memory, data flow, garbage collector). Processes can send messages similar to e-mail. Processes receive the messages sent to them (as well as broadcast messages). What will they do with them - it depends on the process, on nothing else. This allows you to do these tricks, as an update of the program during its operation. So you can reinstall the operating system, and then proceed to answer your interlocutors by e-mail. These will look like you were late with a response, but communication is not interrupted.

Yes, all of them possible to organize in the Euphoria. Instead of messages - stack of maps. Instead of prototypes - maps containing not only data, but also pointers. You can organize the stack of messages. Not necessarily between several programs, even though it is possible (via sockets, for example).

I'm not saying that we should implement this paradigm. I was just demonstrating the flexibility of different approaches. No matter what the approach. Maybe later I will demonstrate a prototype implementation of a prototype paradigm. :) But what do you propose to Euphoria? Why Wirth did not stop at the stage of Modula-2, if modularity is enough? By the way, modern (I mean, younger than 20 years, haha) Pascals is not improved Pascal, but degraded Modula-2.

What is Euphoria in such sense? I think it is somewhere between modern Pascal and Modula-2. Maybe I'm wrong, and it is placed below. But not above, sure.

15. Re: Prototype-Based Programming

• Posted by jimcbrown (admin) Sep 26, 2013
• 2199 views

No, there are much easier ways. Read the documentation.

Actually, this is less true of 4.0 than of earlier versions. We have a couple of features that are not exactly purely procedural now.

Why? Nothing in Euphoria prevents complex programs from being developed.

Yes, I do this all the time with Euphoria.

Or you could reinstall a more conventional/traditional operating system without these features, then proceed to answer your e-mail. E-mail is not meant to be real-time, there's no need to use any of Erlang's tricks or novel features to do what you are describing here.

You lack a sufficient grasp of the language to make that determination, based on your inaccurate explanations on the uses and pitfalls of Euphoria thus far. Even if you did however, you haven't adaquately explained why this is the case or what you'd want to do about it.

17. Re: Prototype-Based Programming

• Posted by mattlewis (admin) Sep 26, 2013
• 2210 views

I whipped up a really simple framework for doing prototype based programming in euphoria. This probably duplicates some of the old OOP libraries in the archive, except that it uses euphoria's maps and it has no error checking.

-- prototype.e 
namespace proto 
 
include std/map.e 
 
public type prototype( object p ) 
	return map( p ) 
end type 
 
public function new( object p = "" ) 
	if prototype( p ) then 
		return map:copy( p ) 
	else 
		return map:new() 
	end if 
end function 
 
public function call( prototype p, object method, object args = {}) 
	if atom( args ) then 
		args = { p, args } 
	else 
		args = prepend( args, p ) 
	end if 
	return call_func( map:get( p, method ), args ) 
end function 
 
public function get( prototype p, object property ) 
	return map:get( p, property ) 
end function 
 
public procedure set( prototype p, object property, object value ) 
	map:put( p, property, value ) 
end procedure 

...and then it could be used like so:

-- prototype.ex 
include prototype.e 
 
enum 
	NAME, 
	LIFEPOINTS, 
	GREET 
 
prototype creature = proto:new() 
 
proto:set( creature, NAME, "" ) 
proto:set( creature, LIFEPOINTS, 100 ) 
 
function person_greeter( prototype p ) 
	printf(1, "Hello, my name is %s\n", { proto:get( p, NAME ) }) 
	return 0 
end function 
 
prototype person = proto:new( creature ) 
proto:set( person, GREET, routine_id("person_greeter") ) 
 
prototype bob = proto:new( person ) 
proto:set( bob, NAME, "Bob" ) 
 
 
function hispanic_greeting( prototype p ) 
	printf(1, "Hola, me llamo %s\n", { proto:get( p, NAME ) }) 
	return 0 
end function 
 
prototype juan = proto:new( person ) 
proto:set( juan, GREET, routine_id("hispanic_greeting" ) ) 
proto:set( juan, NAME, "Juan" ) 
 
 
prototype luis = proto:new( juan ) 
proto:set( luis, NAME, "Luis" ) 
 
proto:call( bob, GREET ) 
proto:call( juan, GREET ) 
proto:call( luis, GREET ) 

$ eui prototype.ex 
Hello, my name is Bob 
Hola, me llamo Juan 
Hola, me llamo Luis 
 

Obviously, any method needs to have the prototype object be its first parameter. Method / property identifiers can be whatever you want. I used an enum, but you could have sequences or whatever there. If you try to "get" something meant as a method, you'll get the routine id, of course. If you try to call a property, you'll likely get an error, unless the value is a valid routine id and your arguments match the signature of the target.

Matt

19. Re: Prototype-Based Programming

• Posted by mattlewis (admin) Sep 26, 2013
• 2196 views

I don't think that we do. I think that they're mostly pretty straight forward. For most uses, new/put/get with default options will probably be enough.

Obviously, I agree.

If you're talking about "class" files, then you've left prototype based programming, where I think the answers are pretty simple and obvious: each object has its own map of properties and methods (this is pretty much what javascript objects are). In my library, objects are really just maps, along with some helper functions to make them nicer to work with. They're not as syntactically sweet as using typical dot notation.

One interesting thing about this is that a map is really an index (i.e., a pointer) so you aren't passing a map's data around, but passing a reference to the map's data. So a method could alter a map without you having to assign the result like you would if the object were a sequence. Also, different prototype objects could share references to prototype objects. This saves a lot on performance due to reduced copy on write operations that you'd need if you were passing sequences around and changing them. The map library goes to a lot of trouble to avoid copy on write where possible.

For a class based approach, you probably need to have each class with its own map, and objects keep a reference to their class type so that the framework can reference the map to get work done.

Matt

21. Re: Prototype-Based Programming

• Posted by TheresNoTime Sep 28, 2013
• 2067 views

Either I do not understand documentation, or you do not understand what I meant. Please indicate appropriate chapter of manual by your finger.

Complex program can be developed in any language. Cobol is ugly, but many large cobol-applications are still living, and even continue to grow.

WHAT??? HOW??? For example, I create ineffective function Factorial. When i=1000, I noticed it and create effective version. How to change contents of Factorial() on the fly, that the program has continued to work and previous calculations are not lost?

export function Factorial(integer x) 
  ... 
end function 
 
for i = 1 to 1_000_000 do 
  puts(1, Factorial(i)) 
end for 

OMG. You don't understand. Emails and OS was analogy. You can shutdown part of Erlang-program and install new version. All the other parts did not notice.

23. Re: Prototype-Based Programming

• Posted by TheresNoTime Sep 28, 2013
• 2093 views

I did not say I need it. It was an example of the Erlang's versatility. Perhaps this complication in the form in which you are using it. Because there is no Euphoria means to do so, and your solution - it's a crutch. When the partition of the program into independent modules supported on the design level, it is a huge help. Manner dosn't matter - Erlang's messages, PowerShell's cmdlets, Zonnon's components... Euphoria's C-like DLLs are in a different row.

It looks completely different. The closest analogy - two (or more) programs that operate in parallel and communicate via sockets.

Concatenative programming languages ​​do not have this problem because the scalability, in fact, the only element of the language. :)

I knew all this before. As I suspected, you do not understand me.

25. Re: Prototype-Based Programming

• Posted by TheresNoTime Sep 28, 2013
• 2216 views

So, I want cocktail. ;)

You did not want to understand the context in which the library is referenced. Python and Java not required C-DLLs in the sense in which I mentioned them. Python is possible to expand the standard means of Python. C-DLLs are used for speed or for access nonexistent features. But how to expand Euphoria? C-DLL?

http://clck.ru/8qnid

Very funny. You found the manual, which says that the car can emit beeps and decided that the car - it's a hunting decoy.

NO. You don't understand, what is cmdlets really. They are not programs, they are classes. Cmdlet is run not in a separate process, but inside PowerShell. This makes it possible to object exchange (in the sense of OOP) between cmdlets.

If I have to cross the terrain with sharp stones, I'd rather ditch the Ferrari, but do not go barefoot.

OMG. Do not cling to the words. I do not remember such things, preferring every time specify in the documentation. Explain otherwise. It would be great if there was a standard way to establish communication between the two programs at Euphoria. For example, I pass the map to function and get a sequence. I can send to DLL a few numbers only. That's enough to send signals or memory addresses. You can make a loop and pass numbers one by one, then restore original format and order, but it is ugly. You can save to file, but it is fraught with collisions. And so on. There is no easy way. PowerShell have such way. Actually, this is how it works. When you send picture from one program to another by unix-pipeline, it seems like you put picture and get picture, but internally it is just bytes flow. When you send picture from one cmdlet to another cmdlet, it is picture internally.

27. Re: Prototype-Based Programming

• Posted by mattlewis (admin) Sep 28, 2013
• 2125 views

Yes, there's a lot of potential there, but we haven't capitalized on it much. I started an RPC library a few months that I plan to use with wxIDE to implement remote debugging:

https://bitbucket.org/mattlewis/euphoria-rpc

It's fairly simple right now, but it basically works. Also, the std library has serialize.e, so we can serialize and deserialize euphoria objects (which my RPC library uses).

Matt

29. Re: Prototype-Based Programming

• Posted by useless_ Sep 28, 2013
• 2083 views

Also, we can now load and kill DLLs at will, so if you don't like the code in one, write a new one, kill the old one, load the new one. Save data somewhere in between.

useless