AltME groups: search

I think, you can achieve this with a preprocessor written in REBOL, 
that parse your scripts and remove the comments, before doing the 
script.

Something like:

out: clear ""
script: {

 for /*(set)*/ myvar /*starting from*/ 1 /*reach*/ 10 /*use the stepping*/ 
 2 /* and execute*/ [
		print myvar
	]
}

parse script [some [
	copy s to "/*" (append out s) thru "*/"
	| copy s to end (append out s) 1 skip
]]
do out

Not difficult, but is it necessary, and is it rebolish? I haven't 
done a deeper thought about it, but I would guess, it's as easy to 
implement as long strings { ... }.

And you could probably find other languages with similar, but other 
syntax, and programmers from those languages would ask for their 
way and on and on. Do it in a preprocessor!

Geomol, one year ago NickA wrote about a similar feature available 
in LiveCode. Their language is not so flexible as REBOL, if I remember 
correctly only native and not user generated functions have accept 
neutral strings line "at, the, after" to insert in the code.
Isn't a REBOL goal to be more human friendly ?

We all use descriptions and conections words every day. Inserting 
it *for free* inside a line, eeverywhere you want, makes a language 
more readable.

I think, most will find it harder to read with comments in the middle 
of lines. You can break code over more lines in REBOL, and that way 
add comments in the middle of lines.

One frind of mine like named arguments to functions in the call of 
the function. You can probably do that in REBOL easily too. Create 
a function, that remove the names of arguments, that is sent in a 
blok together with the values, and then call the real function with 
only the values.

Or maybe better than my do-this example, create a dialect, where 
all function calls work with named arguments. The parsing then need 
to look for words, that are functions, find out how many arguments 
they take and remove the argument names. And do it recursively also. 
Should be possible, I think.

Geomol, I have alway in mind using:

for /*(set)*/ myvar /*starting from*/ 1 /*reach*/ 10 /*use the stepping*/ 
2 /* and execute*/ [print myvar] 
and see it in the editor as:

for (set) myvar starting from 1 reach 10 use the stepping 2 and execute 
[print myvar]
where the "neutral" words are in different colors.

Tilde is an option. There are three function in REBOL using that 
char, the function variations of and, or and xor. I call those and', 
or' and xor' in World, so that's a possibility in R3, if people wants.

And then tilde can be used in URLs, like:

>> type? url://~a
== url!


I can't judge, if that's a problem, if tilde should be used for comments 
too.

Gregg, in my scenario I propose filler "comments" and not words. 
This should not change REBOL language but only commenting.

The Editor will be in charge for diplaing these comments in different 
colors.

Adding filler words should be a major change in REBOL. I don't wont 
to propose something so big.

Oldes, In my keyboard (italian) there is no tilde key.
The only available characters are
|
 (but I ithink it is already use in REBOL.
and
^

Another proposal would be to have ";" as alternate ending for the 
comment other than CR
In this way we can have 


for ;(set); myvar ;starting from; 1 ;reach; 10 ;use the stepping; 
2 ;and execute; [print myvar] ;standard comment with stops at the 
end of line

Filler values of any kind change REBOL. If you really want to do 
that, experiment by using tags as comments, strip all tags after 
loading your code, then DO it. Now see if if really helps people 
when they use your simple dialect. Can the same be acheived, roughly, 
with reformatting and end-of-line comments? 


None of us here can tell you if it is really helpful. It's different, 
but that doesn't mean better. 


Using semicolons as an alternate comment end mark is a HUGE change, 
and not for the better IMO.

Yes, the tilda used in urls is a showstopper. Personaly I don't think 
that inline comments are necessary and add some readability. I'm 
fine with current state.

I know, how and why it works as it does today, but should it be possible 
to:

>> comment { ... } 42
== 42
>> ;{ ... } 42
== 42		; <--- this doesn't happen today.

Gregg, Oldes, it is a feature for people who like it.

Having verbose lines really help understand the language but it is 
not for all. I think about it for new user and to say to the world 
"you can write human language resembling lines".

I was sure that professional rebolers would not find this useful... 
but it is not useful for them, for us, it is for another part of 
the world.

Giuseppe, all I'm saying is to experiment first. Dialects are great 
for that. I'm not against all verbosity, and was reminded recently 
by an article I read that we can add value by adding information 
and structure to our programs. And I think the idea of the editor 
knowing, and highlighting, filler words is great. At this point, 
and I'm happy to be convinced otherwise, the standard REBOL interpreter 
should not handle it.


Is REBOL more like math or natural language? Would you implement 
comments the same way if you said "Math"?

#[[Giuseppe

  REBOL language differs from other languages because you can write 
  "human resembling" code lines.

  During the past weeks I have thought about a way to make more understandable 
  the language in a simple way

   now you can write:

   mypage: read http://www.rebol.com

    I whish to write:

    set the variable mypage: reading from http://www.rebol.com
]]Giuseppe


Carl really took some "architectural" principles of Rebol from human 
laguages making it resemble human languages in that respect. However, 
he did not want to immitate everything. Sorry, Giuseppe, but I must 
say that you are missing big what is the main principle of advancement 
relative to other computer languages. It is dialecting and not the 
ability to write the primitive and verbose

    "set the variable mypage: reading from http://www.rebol.com"

Ladislav, I disagree with your (not so) hidden opinion that the feature 
I proposed is not useful at all.

During my early days and even now I find difficult to uderstand REBOL 
code without "connectors" words which makes a line more descriptive.

I agree that dialecting is a big advancement. I also like the opportinity 
to write "first, second,... last" but  adding ";" should be a big 
change and you should really walk in the shoes of a newbie where 
reading a line with connector words really makes the difference.

Geomol: "is this a good thing ?"
Only time and experience will tell.

But I am sure that if I write on the top of a web page a full line 
of code and the If you can understand this, you can write code in 
WORLD" people will feel they can.

*But I am sure that if I write on the top of a web page a full line 
of code and then "If you can understand this, you can write code 
in WORLD" people will feel they can.

On the same subject, I wish I could write:

	foreach item in the serie [do something]

and I'd like to have single-word comments so it become:

	foreach item /in-the serie [do something]

(the slash is only a possible (?) solution)

You could even redefine IN, and get exactly, what's asked for:

>> series: [1 2 3]
== [1 2 3]
>> in: the: func [v] [:v]
>> foreach item in the series [print item]
1
2
3
>>

Sometime I think the current keyboards and characters are limiting 
from programming purpose. We need more characters.

Whether the primitive verbosity property could be useful and for 
whom is a matter I did not want to discuss at all.

Ladislav, I prefer to loose 9 out of  10 "wow"  and having 1 continuing 
his rebol education than having 0 programmers attracted.

Giuseppe, I know you think it will help, but that doesn't mean it 
will. So, do an experiment to find out. Or look at other languages 
and see how many successful languages do it. VB was widely adopted 
by non-programmers and it had very few connecting words. FOR and 
FOR EACH being the main examples.

it will make it 90% less usable.

 - what I mean is that the beginner will grow out of this in a matter 
 of, perhaps, days and then it will only be seen as a nuisance than 
 an advantage. REBOL is about words and symbols and now we're spending 
 words and symbols for no real purpose.


I'm afraid it will just confuse and complicate programming in REBOL, 
when you first learn it with fill in words and then without those 
words, and simply slow down the learning process.

Good news are that there already is a language following this design 
goal:
#[[Wikipedia

One of the design goals of it was that non-programmers—managers, 
supervisors, and users—could read and understand the code. This is 
why it has an English-like syntax and structural elements—including: 
nouns, verbs, clauses, sentences, sections, and divisions. Consequently, 
it is considered by at least one source to be "The most readable, 
understandable and self-documenting programming language in use today. 
[...] Not only does this readability generally assist the maintenance 
process but the older a program gets the more valuable this readability 
becomes." On the other hand, the mere ability to read and understand 
a few lines of its code does not grant to an executive or end user 
the experience and knowledge needed to design, build, and maintain 
large software systems."
#]]Wikipedia

Some other good news:

- the wheel has already been invented:
- the language is mature, having been designed in 1959


So, Giuseppe, aren't you eager to try it? It might be quite an enlightening 
experience for you, realize that you would immediately understand 
the expresions!

And other good news: it shares 60% of REBOL's name!

None of our arguments is based on real world experiments. So my argument 
are still valid like yours. Ladislav, why don't you try to add this 
feature and lets see if the user will like it ?

Ladislav, why don't you try to add this feature and lets see if the 
user will like it ?
 - I think I did explained it sufficiently:

- such a feature has been implemented in a language since 1959

- I do not feel responsible for implementing every feature you may 
find useful

not finished imo. But I tried to put some code in a task - wait, 
print, and IIRC it did so ... console was freed, later it printed 
the message. But it was long time ago ...

I'm about to look deeper into tasks and networking and was wondering, 
if Carl wrote something about this, and how much is already there?

I was just thinking, because they're lightweight and also have the 
yield functionality, you just mentioned.

#[[AdrianS
...if you have the following in a script:

print sumn 1 2
print "hello"

The "hello" doesn't print.
]]AdrianS


Yes, that is not surprising. SUMN (referring to its last version) 
is taking unlimited number of arguments and stops taking them only 
if it obtains an argument that is not a number. In the above case 
SUMN consumes the ''print word, that is why nothing is printed. To 
stop SUMN before it consumes the 'print word, you can use either 
paren:

    (sumn 1 2)
    print "hello"


or just supply NONE (or some other non-numeric value)  to be consumed 
by SUMN as the last (stopping) argument

    sumn 1 2 #
    print "hello"

On the other hand, using evaluated argument passing style, the expression

    sumn 1 2 print "hello"


would work as you expect since the PRINT call would be evaluated 
and its result (the #[unset!] value) would be used as the SUMN stopping 
argument.

#[[Adrians

Among other things, how is it OK to invoke arg-adder without providing 
the one arg it expects when you have "return/redo :arg-adder?
]]AdrianS


RETURN/REDO is a construct returning (in this case) the ARG-ADDER 
function and setting up an indicator telling the interpreter that 
after obtaining the function as a result it should reevaluate it 
collecting the respective number of arguments for it (one in this 
case).

Thanks, Ladislav. I was hoping that there would be a "magical" way 
of telling Rebol to somehow back up and re-evaluate the consumed 
stop argument. Maybe return could have a /back refinement which you 
could use when exiting a variadic function. What do you think?

I think gstreamer is also open source, and might be less complex 
than avconv.

Maybe if you could find libraries, that can do this, and call them. 
World can call routines in libs, and REBOL can too (afaik).

yes, and it would be lovely to be able to do that in REBOL and World. 
But (I can only talk for World) the language needs to have legs first, 
before we can think about flying.

and World can barely crawl now.

Maybe return could have a /back refinement which you could use when 
exiting a variadic function.

 - not a good idea. Variadic functions don't differ from "normal" 
 functions in this respect. If consuming an "undesired" argument, 
 it actually is an error. That is a good enough solution as far as 
 I am concerned. In case of SUMN this behaviour can be also implemented 
 by requiring the argument to always have a specific type. e.g. [number! 
 none! unset!], where number! would be a "normal" argument while none! 
 and unset! would be stopping. Any other argument causes an error, 
 which should suffice for you to note that something went wrong.

I will have to think about this. I'm curious, though, what your opinion 
is of return/redo given that BrianH said in the SO chat that it had 
been decided to remove this and yet you documented it and showed 
its usefulness. Later, Brian also said:


Ladislav proved that RETURN/redo needed to be removed, by writing 
example code that was safe to run, but used methods that were provably 
unsafe if used mistakenly or maliciously. It would actually take 
a programmer of Ladislav's calibre to use the feature safely. But 
DO function is provably OK.

So, is the intent to remove the feature?

Interesting, I tested with the old R3 version and the latest Saphirion 
version, it doesn't close the console.

Did anyone started a R3 code-review and already took notes that are 
published?

Gregg and Andreas: 'xor seems to work, for the most part.  I have 
to do some more testing to know for sure.

Bo, I'm not sure, if that makes sense. What you're suggesting is, 
that this should be possible:

	(read/binary %file1) - (read/binary %file2)


So it's like looking at a long sequence of binary data as a number? 
And if the series are of different length, they should be right aligned. 
Is that really useful? :)

R2 can use strings in AND, OR and XOR, like binary!, but they're 
not right aligned.

R2 and R3 works the same in this:

>> (to integer! #{1111}) or (to integer! #{22})
== 4403
>> to integer! #{1111} or #{22}
== 13073

I guess, that's expected behaviour?

The downside to datatypes is that it is hard for the developer to 
determine proper behavior of different operations on the different 
datatypes.  Like, what should happen when you add a char! and an 
integer!...  My opinion would be that because your first argument 
is a char!, you want to increment/decrement it by the value of the 
integer!.  This could be useful in some situations.

strange... it seems related to the version of R3 I was using.  I 
changed to using the version on ../src/tools/make-headers.r and it 
seems to work.

Hmmm...interesting behavior.  I am trying to use R3 to act as a TCP 
server on Linux-ARM.  Here's a code snippet:

	if probe port? prt: wait [1 camsrv][
		probe cmd: copy prt
		call/wait reform [cmd "> cmdout.txt"]
		insert prt probe read cmdout.txt
		close prt
	]


The probe at the top returns 'false when there is no TCP activity, 
but it returns "TCP-event accept" when there is, and then it just 
sits there.  Escape (ESC) and CTRL-C will not break out of R3 at 
that point.  CTRL-C just outputs "[escape]" each time it is pressed, 
but doesn't escape.

R3 does not use COPY and INSERT on ports, it uses READ and WRITE 
instead, but also, it is always async, so something like the above 
will not work.

Gab and Andreas: Thanks for your feedback!  I'd never done server 
programming with R3 and I forgot it was asynch by default.

I have a couple questions about how to deal with actors and I think 
an example will illustrate it best.

Cyphre wrote 2-Apr 2013 22:03:
For those interested in the 
alpha-channel change": ..."


It's a good change to get the alpha-channel 'right' or similar to 
most other standards. Have there been thoughts about including the 
alpha-channel with the RGB values, so it becomes RGBA, which we know 
from OpenGL and other places?

From my R3 console:

>> i: make image! [1x1 #{01020304}]
== make image! [1x1 #{
010203
}]


The alpha values seems to be left out. (It might have changed in 
newer versions.) Setting the pixel will include alpha values:

>> i/1: 1.2.3.4
== 1.2.3.4
>> i
== make image! [1x1 #{
010203
} #{
04
}]


But it seems, the alpha channel is separate from RGB values. Why 
not always have the alpha channel, and include it with the RGB values, 
so we have: [1x1 #{01020304}]

And related: have there been thoughts about setting origin of images 
in the lower left corner instead of upper left? When I use REBOL 
to draw graphs (of scientic values), I always find myself flipping 
the y-axis. Putting origin in lower left should make such code easier. 
Textures in OpenGL has origin in lower left.

Do you see my point? For a target, we need to estbalish a time/money 
budget and ratio.

Right, but how did they get funding and support? For Rails, at least, 
they wanted to build the tool for their own use. And they're built 
on top of other infrastructures.

And users have to care about what these new tools bring to the table.

Bit of both in my view. Money to support full time development. And 
the knowlegde to know how to is also sparse. A little bit extra on 
info and tutorial like stuff could maybe get some more people started. 
Google's summer of code like the HAIKU project is putting to use 
is beyond reach for the small base of devs for instance.

We are on the other hand lucky to have the enthousiastic giants we 
have now. It is enough to let the projects live on, but not in the 
way blooming as we feel should be the case. 

Yet the progress even in the last weeks is a great accomplishment, 
cannot be said enough..

One of my views is a way of providing a webhosting service based 
on REBOL/Red and additional open source technology.

shure, as long as you have a precise end-result with milestones, 
 time estimates, and realistic goals.

but would it actually end up working?

My gut feeling is that it would be tough. You need good rewards to 
entice people, and our community is small.

We need more momentum. Meaning a small usable base to start serious 
advocating the pro's with and possibilities of generating a little 
money. Attracting young programmers/students willing to contribute, 
one advantage for students is that not everything is carved in stone 
yet. (Only what we want to achieve and the toolset is chosen)

So you could start with a small Kickstarter campaign just to get 
some momentum going, and then maybe follow it up with a larger one 
once momentum is up.

If we can pitch something about it that would appeal to the general 
public (easy-to-develop apps for Android that also run on embedded 
systems and full computers), then maybe we'll get some new interest. 
 Especially for popular Kickstarter search terms like Android, Raspberry 
Pi, Arduino, etc.

It's the IF and MAYBE that I'm concerned about. :-\ Again, without 
rewards, who will pledge?

So, what's interesting about it is, that one gets access to a complete 
vertical technology stack. The black-box dependencies (those that 
you can't influence) are mostly zero. Of course you don't have a 
big community, eco-system etc. around. But I'm coming more and more 
to the point that I don't need a big eco-system, I need the right 
eco-system. I don't want to use big frameworks, zillions of libs 
etc. This all makes product development a hell.

A mean and lean technology stack, that is maintainable, can be adjusted 
to some special needs with the fundamental things available is everything 
you need.

What I would do if I could afford is, is to re-implement R3 using 
the D language. This should result in a more simple code base (Carl's 
code base is in a very good shape, so don't take me wrong), and using 
this we would close the most fundamental missing parts in R3. There 
are around 5-8 topics that need to be addressed. Andreas and I just 
had a short chat about this this week.

Than we have fundamental frameworks and libs like R3-GUI etc. this 
is a mix of Rebol code and enhancements on the C/D level.

Than we have the product level, that's what's visible and keeps the 
fire burning. Spitting out cool applications in a fast rate is key. 
I see several markets to address: B2B tools, mostly more effort to 
develop but long lasting and big money. Consumer or Internet market 
applications. More low cost but high volume stuff.

And mobile things. Whatever app is missing today I don't know. I 
can imainge some cool B2B mobile apps, that really help.

That's it. Take the assambly we did and use it to be 20 times more 
productive than anyone else.

Some ppl need some solution now, whereas Red seems being really far 
from completion, and that's simply another aspect ....

When I have talked to Carl about Red, he is very interested in it, 
but wishes he had more time to delve into it.  He has great respect 
for Doc and his abilities.

When I first talked with Carl at length about Rebol in 1997, his 
reason for creating Rebol was because he had learned and used so 
many languages, but they all fell short of his definition of a "perfect" 
language.  He liked Lisp and Smalltalk, but there were issues with 
them as well.  Rebol was his attempt at filling in the holes and 
creating a multi-purpose language that made simple things simple 
to do, while still allowing complex things to be possible.  (I'm 
going back in my memory 16 years here, so I hope Carl forgives me 
if I left something out.)

Because of the above, I can't imagine he wouldn't want to see any 
Rebol-like language to succeed as long as they held true to his vision 
of creating a language that made simple things simple to do, while 
allowing complex things to be possible - with efficiency and cleanness 
of design.

I simply believe, that during the Devcon, it will be the right time 
to exchange some ideas and explanations. Looking forward to the outcome 
of the meeting :-)

REALLY hard to wrap my head around the dialect.. and its VERY verbose.. 
yet using the Flash IDE = simple.

It depends on utf-8 and ucs2 projects, zlib if you want to decompile 
some flashes compiled in Macromedia Flash

What you should know is, that the dialect is almost useless if you 
don't know how Flash works and don't know the ActionScript. The good 
start is to registed and download SWF file format specification from 
this page: http://www.macromedia.com/licensing/developer/

and download ActionScript help file as well

And of course the dialect is not for making animations! Use drawing 
programs to make animations. The dialect is for example to do things 
like to generate games for the tiles game: http://box.lebeda.ws/~hmm/rebol/swf-tiles.r
--- I'm sure you would not like to do it in Macromedia authoring 
tool:)

how about using 'call and some exe?

all i read was "he zlib dll support for decompressing foreign swf 
files is missing" and remembering there are some small zip-exes for 
commandline.

You can compress/decompress swf's, but some of them (the foreign) 
use probably latest zlib and Rebol cannot decompress them

IIRC some script in the library says there are more options, buffer-size 
and something. rebol can output nearly gzip, but read only a specific 
version.

Just one last thing for now, it's safe to compile only to version 
swf6, I donloaded the spec for swf7 only yesterday and swf8 is not 
documented at all.

Interesting: just downloaded this free ActionScript compiler http://www.mtasc.org/
and will try if it would be possible to integrate it with the rswf 
(so I could use *.as file for actions without need to parse it in 
Rebol)

go here: http://www.macromedia.com/cfusion/entitlement/index.cfm?e=file_format
register and download

Thanks Oldes, I finally got it and now can learn! How cool. I was 
downloading everything but this doc. : ^)

where is he difference between rswf and mtasc?

Was just checking it a little bit, and it looks that the mtasc is 
pretty complicated. First action script I wanted to compile using 
mtasc was not compiled successfully:) The biggest difference is, 
that the mtasc is only ActionScript compiler, but in my dialect one 
can compile everything (shapes, sprites, images, sound). You must 
use swfmill or how they call it to compile such a things (and it's 
using XML so I thing it's not much useful for making complete application 
in it (as I do).

Oldes: I've updated codeconscious.com for your new link. Linking 
to old and new now.

Thanks, the dialect file updatet a little bit again and there are 
3 new (flash8) examples

And again updated (fixed conversion of 4digit-issues/tuples), 2 new 
examples.