AltME groups: search

As it stands, Boron seems reasonably capable of processing strings 
and lists - I could certainly have a go at writing some useful stuff 
if CGI were possible.  I'll send Karl an email...

Right  now I'm very excited to be playing with a working open source 
REBOL implementation in Windows :) I wonder what dependencies it 
has, and if it can be compiled to run on Windows Phone or any other 
potentially useful operating systems.  Even just for simple file 
managment and text processing, it would be really cool to see this 
running somewhere where real REBOL isn't currently available.  And 
since it's open source, there's potential to expand it's capabilities.

Look like it needs files from  http://wsrebol.sourceforge.net/- 
 currently a 404 error.

Yep (and there's a devpak for the BZip2 library :)

I had a quick look at Boron and at second look I got the impression 
that it can be a real alternative, if  R3 does not move faster.

Has anyone a project file for Codeblocks and Boron under Windows 
or some hints how to do it?

sqlab: you can have cmake generate a codeblocks project file for 
you

Kaj, thanks for noting that standard input example - it is new.  
In June, Boron's user manual version was 0.1.2 and the windows release 
was 0.1.4.  It's really encouraging to see work accomplished :)  
I donated a small amount back in June to Karl using the paypal link 
- if he's motivated by money to do more work, I'd support that without 
reservation.  I don't have much time right now to explore much, but 
I'd love to see a continuing active open source alternative.

Here's a tiny demo of Boron generating a web page on Cheyenne:

That's through Cheyenne's CGI mode, so with standard input reading, 
it should also be able to handle a POST request

It's a console program, so you must start it from the shell

It's likely an app bundle because it includes a dynamic library

That would be a good piece of code to contribute to Karl :-)

Yes, it's a console program, so must be started "manually"

So do you get the Boron console when you start it from a terminal?

If extra code is required on OS X, then that can be expected from 
finished commercial apps, but Boron is a volunteer project a year 
old

How do you start R3 on OS X? Isn't there an app setting where you 
must tell OS X to start a command line program in a terminal?

A bundle is simply a directory, which contains specific directories 
and has a specific icon. OSX recognizes such directories as applications. 
Inside are libraries, icons, images and executables of various CPU 
platforms. The user then sees the directory as an application, which, 
when double clicked, automatically runs the correct executable inside 
according to CPU platform. You're not supposed to go inside a bundle 
to start the program.

How do you start the host kit version of R3, which has a separate 
library?

I'm not sure if there is a hostkit version yet for OSX. Mine comes 
from Carl.

A bit surprizing move, I guess that Red project is stimulating competition. 
:-)

well, then R3 is not a competition :-)

There is a /usr/bin/llvm-g++ command under OS X. The man page say:
llvm-gcc uses gcc front-end and gcc's command line interface.

So maybe it isn't "clang"!? I'm not sure. It's my first real experience 
with LLVM.

There also is a /usr/bin/clang
Maybe I should try compile with that.

By the way, why haven't you used LLVM for building World? As it is 
VM-based, LLVM would have been a good match.

So it seems, I made a good choise with gcc, because 1) it was easy 
to make World compile with LLVM and clang (if I choose that path 
now) and 2) it seems, some code doesn't work as intended with LLVM 
and clang.

LLVM isn't really VM-based in the sense that bytecode VMs are. The 
VM is a compiler backend, but the code it requires tends to have 
to be specialized a little for the actual machine. As the developers 
of Portable NaCl have been discovering, it's not necessarily that 
good at being a portable VM.

Sure, LLVM is not a "VM", it's a framework for building compilers, 
interpreters, VMs,...But for a VM-based language implementation, 
it makes sense to strongly consider the LLVM option.

LLVM can also be used as a set of compilation libraries, yes. And 
you can implement a JIT that way, yes.

But they also provide a set of ready-built binaries which work as 
a nice AOT compiler for C/C++/ObjC. I.e. just like GCC or MSVC or 
ICC or ...

Or when you want to put documentation before the header, or embed 
the script in a block in another type of file.

- Gave series an overhaul, so compiling blocks should really work 
now. Let me know, if it doesn't.
- Changed system/version/platform, so it's now a word.
- Added new tests.

You found a bug! :) Uploading fix ...

A helper function to reset compilation state would probably be helpful.

(Not sure if just calling COMPILE w/o context after modification 
would always be the same. Will have to think about it a bit more, 
but I have a hunch that it is not.)

Yes, I agree to some degree. If APPEND was a native, it would really 
make sense (I guess). We could add a compile to the APPEND mezzanine.


I think, the compilation reset would just be COMPILE. Don't you think?

A basic example:
c: copy []
f: func [x] [x]
append c [f 10 20]
;; recompiling c here, do c would == 20
f: func [x y] [x * y]
;; recompiling c here, do c would == 200

That code leads to an error, if c is compiled before f is redefined. 
The error system isn't very good atm., and I'll probably work on 
that next.


I need more experience with World and more examples to say, if a 
compile reset is a good idea.

Correct. World is not designed to cope with such cases, where words 
changes from functions taking arguments to passive non-function values, 
or if number of arguments changes to a function. To change the behaviour 
of the c block, a compile is needed. So question is, if that compile 
should be executed by a COMPILE call, or if the compile state of 
the block could be reset, and in this case, it would be compiled, 
the next time, it was executed with DO.

Currently we have a way to force (re)compilation (with COMPILE), 
but we don't have a way to drop previous compilation.

I am a strong believer that in cases such as this, whatever is helpful 
internally should also be exposed at the user-level.

My personal view is, that it's sort of bad programming practise to 
change number of arguments to a function in the middle of a program, 
or to change a work from meaning a function or operator to meaning 
e.g. a number.


But I think, it's possible to cope with such strange situations, 
because we have COMPILE.

(Then a mezzanine APPEND could just reset compiled state, and would 
behave identical to INSERT in that aspect.)

Hmm, that creates a new function, though, doesn't it?

And I get a malloc error, when doing that a couple of times. Yes, 
crash. I'll hunt that down.

(Well, I can't, as I get a crash immediately :)

I don't think you should keep the compiled block in memory when DO 
is used.

Compiled blocks (including the nested ones) should be linked with 
functions only (whe functions are created).

I don't think it would be a real perf problem  because DO is not 
used that much to execute standard code in an app.
Just my opinion though.

A possibility, but I think that would on the one hand make implementation 
more complex, and on the other would just introduce more semantic 
corner cases.

Such as a block being shared by a function and a global word.

I agree, the compilation of a function would be more complex (because 
of the nested blocks)

Yes, because compiled code would become an attribute of a function, 
instead of just dangling off a block.

Andreas in R3, nested blocks inside a function can't be shared with 
global words.
The body of a function is deep copied before compilation.

Just to say that the R3 model of a function is better than R2 in 
that case

But keeping a "compiled block pool" attached to a function is certainly 
a very interesting idea.

At present without typecheck, World think string! when seeing a pointer 
in a routine spec. And the World types are just seen as comments. 
With typecheck on, the Would types are considered, and only certain 
combinations of World types and libffi (C) types makes sense, like 
string! and binary! for pointer.


I'm about to implement handle!, and maybe handle! should be the default 
for pointer. And then it's required to specify typecheck, if string! 
or binary! want to be used with pointer.

I get a malloc error under OS X (64-bit), when redefining a function 
with code like:

f: make function! reduce [pick :f 1 pick :f 2]


I didn't find the error, so I tried it under WinXP (32-bit), and 
the error isn't there!? Any suggestions?

Glad it helped you, it's a great tool.

More about routines.

The next release of World will introduce the handle! datatype. It's 
used to hold pointers, which are normally handled by structs and 
integers in R2.

If we take the sqlite3_open routine as an example:
http://www.sqlite.org/c3ref/open.html


The routine takes a pointer to a pointer as its 2nd argument, and 
this is the db handle updated by the routine. The handle is again 
used in sqlite3_close:
http://www.sqlite.org/c3ref/close.html


, but this time, it's the handle itself as the argument, not its 
address.


In World, using routines should be as easy as possible, and the consequence 
is, the definition of the routine gets some complexity. World uses 
libffi as the underlying motor to carry out the calls. libffi defines 
15 datatypes, where World uses 14 of them (not longdouble). Beside 
"pointer", I will introduce "pointer-adr", and routines like sqlite3_open 
can use that. Then the address of the handle will be given as an 
argument. Routines like sqlite3_close should just use "pointer", 
and World will internally typecast the handle to an integer (32- 
or 64-bit depending on version), and give that to the routine.

In the above, sint64 is a C type, real! is a World type.

Regarding AS, the REBOL AS-BINARY and AS-STRING can be achieved with:

as binary! ...
as string! ...

But it's also possible to do:

w> as issue! "abc"
== #abc
w> as paren! [a b c]
== (a b c)
w> as tag! "title"
== <title>

and many other combinations.

wow a lot of activity here since I last checked...

one little note about handle! is that it should be immutable and 
cannot be created from within the interpreter beyond defining a null 
pointer, as above.   value holding handles should only be returned 
from a routine.


the idea here is that you should not be able to mangle handles, for 
a variety of reasons.

its tempting to be able to do:  

i: to integer! my-handle
i : i + 1
some-routine i


but its very bad practice (from within a scripting language) IMHO 
since it allows all manner of crashes to occur, not to speak of security 
issues this can open up as well.

Yes. I made it possible to view the content of a handle with MOLD. 
That should be ok.

Having all the libffi C types should cover all possible libraries. 
(I guess.)

struct! isn't there yet though. I think, structures are needed for 
some routines? Else it's a hard job juggling with binaries.

my only suggestion for structures...  make it so the semantics are 
exactly the same as C.    
i.e. you take a C header file, and do:

replace/all header-string "{" "["  
replace/all header-string "}" "]"  
replace/all header-string "char *" "pointer"
...


and basically you've got your simplest World version of the spec 
 ;-)

also, I would really like if the return value setup for a routine! 
could include an optional  function block which is run on the return 
value.  

it would prevent the very common instance where you have to write 
stubs for the routines (such as normalizing return values on errors 
or converting values to some better internal mechanism).

Geomol, I am reconnectin to the Rebol3 world after a long time of 
absence.

It comes as surprise you new REBOL inspired new language. It is inevitable 
that things like TOPAZ and RED are created after the long absence 
of CARL. There is a stong need from the market and the market is 
US programmers which cannot wait any longer.

First of all a question: which will be the difference and improvements 
comparing to REBOL ?

Difference: Based on a virtual machine, that source can compile to. 
Many different design decisions, but many of those can be redone 
to be REBOL compatible by defining words. This is what %rebol.w is 
for.


Improvements: Faster in many cases because of the VM. I try to make 
it better in all those areas, where I find REBOL not good enough. 
Datatypes like complex! and more in the future. I also try to cut 
into the bone and only create that at the core, that is really needed. 
I see that as an improvement.

You are the project LEADER and you are the creator of this wonderful 
project. You have a VISION, a destination.

Back in time, when CARL was developing REBOL3 he created a roadmap 
explaining us what would be the structure of the language, its modules 
and how they cooperate.

This inspired suggestions from the community, changes in the roadmap 
but more preciosuly it created expectation, commitment and willingnes 
to cooperate.

I'm very focused to get to version 1. When that's done (or almost 
done), it makes more sense to launch parallel projects. If someone 
offer me a business opportunity, I'm willing to change my focus or 
work on specific projects.

You are a programmer but you should be an inspirator and entrepreneur. 
Like a programmer you first released the alpha version before selling 
the idea ! :-) You came out from your BatCave after 2 years of silence 
telling us "look here what I have created". This is good as it proves 
you deliver other than promising. 


Somewhere, in the road to version 1.0 you will need help. It belongs 
to you teling us when you will have clear in your mind the whole 
project. Then, please SHARE THE VISION and ask for cooperation and 
involvement of other programmers.


You are not alone. There is lot of skilled people here. They will 
be happy to give their input to you.

This will avoid being World as a one man project and will put the 
basis for collaboration.

When you will be ready for this I ask you to make few thing:

1) Create a white paper with your vision to let us know what is in 
your mind
2) Set the goals of the project.
3) Open the source but maintain the leadership of the project.
4) Ask for cooperation
5) Build the comminication/documentation infrastructure .

As you may know I am the creator of the REBOL2 DocBase section.

I have asked for long time the upgrade of the software to a later 
version which supports multiple languages.

Now 3 years have passed since then and no upgrade took place.

I am still with the same idea: I believe that documentation and communication 
is everything. If someone has the willingnes to setup a linux system 
with the proper wiki software I am ready to DONATE MONEY for hosting.

It will be the basis for World Documentation. You are a programmer 
and you know how much important is this aspect. I am sure we will 
find someone which could create the official World Web Site.

Somewhere, in the road to version 1.0 you will need help. It belongs 
to you teling us when you will have clear in your mind the whole 
project. Then, please SHARE THE VISION and ask for cooperation and 
involvement of other programmers.


It's pretty clear in my mind, what version 1 is about. When I started, 
I wrote down the natives, which are really necessary to create a 
REBOL like language on a virtual machine. All the other functions 
should be able to be produced from this set of natives. I listed 
about 100. World currently has 83 natives implemented. Maybe some 
of them will get some more refinements before version 1, but you 
could say, the natives are 80% done.


You may think of this project as the Wildman project (see that group), 
not on native hardware, but on a virtual machine.

As things are clear to you I suggest to spend a couple of days creating 
the White Paper, The structure of the programming language and the 
ROADMAP. You may think that you will loose 2 days but I am sure you 
will gain lot more.

Personally I have a great private project in mind and a skilled developer 
for it.

The project is blocked because he want to make money now and someone 
who finances the project.

I told him that First of all we must show a concept application. 
This will sell the application itself and we start fundraising.

Until something usable won't be ready I will not be able to sell 
the idea. He refuses this view and we are blocked.


As you are writing a programming language you are in a worst scenarion 
than us.

You need to have a commercial class programming language ready for 
the mass to sell it and this is not the case.

Commercial Class mean: IDE, Solution for interfacing SQL Databases, 
Solutions for communicating, Solutions for interfacing to other projects.

This is too much for one man to accomplish. You need to live, you 
need money and World is your Hobby project (Isn't it ?)


Open sourcing and delegating is the solution for creating a mature 
project: you seth the path, the specifications, the rules, the others 
will help.


I won't give a Penny and Time to REBOL Tech. because its source is 
closed and this model is wasting my precious life waiting for Carl 
to resurrect.

Open Sourcing solves this problem. Don't you think that if REBOL 
was open sourced many developers would have inproved it in Carls 
absence ? Do you think that someone, like an university will donate 
money to a private held project ? I don't think so.


When we (you) will have a mature project and you will be able to 
show to the world the advantages of your solutions money will come.

Think of SQL lite. There is a consortium behind it. Other open source 
solutions have the same consortiums behind them.


There are many ways to raise money: You can produce vertical solutions 
for your baby.You can give consulency to companies and other institutions, 
you can create products with World. These are few that comes into 
my mind.

You list of 5 things:


1) Not sure, I wanna do that. It takes time away from me finishing 
version 1.
2) I have set the goals for ver. 1.
3) No (see Q&A)

4) "Ask for cooperation" - World would need schemes for the different 
protocols. I will welcome others work in that area. Me (and most 
likely others too) would like to see World on more platforms than 
the current 3. Host kit is open source. I will welcome ports to other 
platforms. (That's what I can think of for now, but I'll keep it 
in mind.)

5) It's faster for me to write the documentation than building a 
comm/doc infrastructure. I'll write the World 'bible'. Work has started, 
and I'll use more time on it, when version 1 is a bit closer.

Point 3 is important for me and many others. If the project is open 
sourced I will be ready to donate. No waste of money donating to 
a private held company.

World is your Hobby project (Isn't it ?)
No, this is a business project for me.

Personal I discourage you from closing the part/all of the source. 

Having learnt from REBOL Tech., the language itself will not sell 
and closing the source closes the opportunity of cooperation.

An open source give you a boost into the develpment and believe me: 
you stongly need cooperation.
However I am not GOD and I cannot force you into making anything.

I could only share my opinions and give you time to thing on them.

:)


About open source, read my answer in the Q&A. It has to make business 
sense to open source. It doesn't atm.

I am not religius to my I will light a Candle in any case a GOD exists 
and could help you :-)

I just thought of another way to help. Make a list of REBOL functions 
missing. There are many missing from %rebol.w

And there already is a wiki started with differences from REBOL at:
https://github.com/Geomol/World/wiki/Differences-from-REBOL

I don't have time to write it. But everybody can write in that wiki.

Now, go try World out. And remember to have fun!

I second Giuseppe.

I will not invest any time or money in a new closed source project.
Not anymore.

Geomol, do you really think you can follow the same model than Carl 
with better results ?

You should aknowledge the fact than nobody win money just because 
they designed or a created a new programming language.
I was possible back in 90's but not anymore.

Of course, there are now six in-development ways to write a program 
in a REBOL like language, half of which are closed source

So haft are open. Do you have a general view, how things are going 
with the different languages?

Yes, efforts are quite fragmented over all these projects. Syllable 
is even still using a seventh language because I can't keep up

It's actually a lot like Linux. Every distro has something you need, 
but none of them has everything you need. If I want to build the 
Russian Syllable website, I can only use R3. If I need system integration 
and speed, I can only use Red. If I need to write web apps, only 
Topaz targets that. If I need open source, I can only use half of 
them. If I need dynamic binding, I can only use the interpreters. 
If I need infix operators, I can't use Boron, although I could use 
its predecessor. Etcetera ad nauseum

I feel not trying to do everything equals failure from the start. 
A language is supposed to cover everything

This is the main reason REBOL has slided for a decade

REBOL started out as a Swiss army knife, and was it bloated and complex?

well, you didn't have direct support for things like Soap in REBOL, 
which I think is a good thing. Being able to integrate with stuff, 
that can do Soap is ok.

Andreas, I've thought some more about the need for a compile state 
reset. Have you?

I have a compiled block which I need to change. I make changes. In 
some cases, compilation state is automatically reset (INSERT), in 
other cases it is not.

If I, as a writer of some code-modifying helper function want to 
also provide the behaviour of INSERT, I can't.