AltME groups: search

GUI, nice would be a clean cross plattform ANSI C lib, handling the 
basic window & eventmanagement

and providing access via a simplified meta-api (VID-DSL). this way 
nearly all script languages could 
use this lib as a native GUI generator.

The DSL link in the docs is going to the French Wikipedia. You may 
want to anglicise that

For people wondering what I was working on these last couple of month, 
here's a screenshot of the customer app I'm finishing now: http://sidl.fr/tmp/generator01.png


It's a visual editor for trading strategies that emits MQL4 code 
for Metatrader-based solutions (FOREX trading). The tree is editable 
and redraws itself automatically (no need to drag all the nodes around 
manually). This app also relies on an intermediary DSL for serializing 
the strategy on disk or before compiling it to MQL4. Here's an extract 
from the corresponding dialect representation of the tree from screenshot: 

start on 1 
if 1 buy 5 take 10 stop 10 on-profit [
    buy 6 take 10 stop 10 on-profit [
        buy 10 take 10 stop 10 loop
    ]
] on-loss [
    sell 7 take 10 stop 10 on-profit [
        buy 4 take 10 stop 10 loop
    ]
] 


All is done in REBOL/View 2.7.6 (to avoid CALL bug in 2.7.8) and 
all the source code is 47KB (25KB for the custom styles and VID events 
callbacks).


I'm at 99% completion of that app, so I've resume the work on Red 
since a couple of days.

One of Red/System DSL goals is to be as close as possible to the 
hardware, not as far as possible. This implies that no arbitrary 
abstraction layers will be ever added to Red/System that can't be 
more or less directly mapped onto some hardware features. 


Exceptions exist when some targets do not provide a basic feature 
that others are providing. For example, ARMv5 family do not have 
integer division, nor modulo support, so I had to implement it manually 
in the ARM emitter in assembler:

https://github.com/dockimbel/Red/blob/master/red-system/targets/ARM.r#L372


Another one is the runtime exception system recently added (THROW) 
to Red/System, which also required a specific assembler routine:

https://github.com/dockimbel/Red/blob/master/red-system/targets/ARM.r#L2008

DSL's will become the norm in about 5 more years.  Seems to happen 
with Carl.  

Carl's multitasking personal computer + 15 years, everybody has it. 
Carl's DVD like TV set top box + 15 years, everybody has it.
Carl's multimedia computer + 15 years, everybody has it.
...etc (there are more).


I would not be surprised of something like JSON becomes semantically 
rich.

Domotica could also be a nice DSL.

Note how the error objects have a great clue in arg1?   This is just 
an example, the code sucks.  Don't think about that.  Think about 
a history professor sitting at a desk and typing
>> mybook: load %mybook.txt

and then fiddling with   >> unique    or  sort   or ...  while trying 
to determine how many times he invoked Godwins Law

I think this would open up reams of new REBOL communities.  Let us 
pros worry about correctness and DSL and user friendly power apps. 
 But open REBOL to general mishmash for the world at large.  No?

doc, its faster to let rebol do what is does best in binary and let 
us take over on those tokens it can't recognise.  just ignoring comma 
would have allowed me use scientific data more than once directly 
 without having to dare understand parse intricacies.


remember that parse IS NOT EASY.  I didn't use it for over 6 years, 
cause everytime I dared, it just blew up in my face.  this would 
provide a simple entry point for more people to support DSL and leverage 
the rich datatype system in rebol, without the need to be a guru 
level reboler.

IMO, designing a good DSL is far more difficult than writing parse 
rules.


I think that ppl here are underestimating the complexity of implementing 
a jump-over-foreign-data feature that would work in the general case. 
REBOL syntax is not based only on whitespaces, but on delimiters 
too : double-quotes, curly and square brackets, parenthesis,.... 


So it's perfectly valid to not use whitespaces at some places, like 
in : "either conditon [true][false]". So what should LOAD do in case 
of, e.g. : "either condition [f,o,r,e,i,g,n,0,1][false]" ? IMHO, 
besides reporting a syntax error at "f," , there's no much point 
returning [either condition "[f,o,r,e,i,g,n,0,1][false]"]. And if 
you think that LOAD could just return [either condition ["f,o,r,e,i,g,n,0,1"][false]], 
then you just jumped over the complexity by creating some syntax 
rules in your mind, but LOAD can't do that. Once LOAD has passed 
the syntax error point, it has no sure way to determine where the 
foreign data ends and where REBOL correct syntax starts again. That 
would require at least, an AI engine (like Gabriele stated above). 
I'm not even sure that all possible cases could be covered that way.


Btw, does such feature exists in any other programming language? 
I've personally never seen or read about such feature elsewhere, 
maybe for a good reason.

we switched from DSL to wireless radio

but one thing you need to highlight, is that for all of your needs 
(code, style, layout, server, client, templates, controls, localization, 
etc) you are using a single highly natural language.    This is the 
power of Dialects, (DSL). 


datatypes are also a great differentiator of REBOL... just run code 
and leave an HTML tag in the code, as-is... that is cool.  most languages 
require literal data to be assigned, but in rebol data IS an expression 
so as long as there are no syntax issues, you can just embed data 
within the code (for whatever reason you need it in source managing 
tools).

When you say dial up, do you DSL, or 56Kbaud modem?

The name server was supposed to be distributed over the world, but 
once when it was down it turned out that it runs on one DSL line

Nope on the creep;  A DSL will be the outcome of the lecture.  I'm 
leaning either toward a password management dialect or a (simple) 
file management command set.

I've downloaded a livePC of DSL but couldn't get it to work for me 
... no internet connectivity.  Maybe it's because I tried a vista 
host.

there is also the DSL which is tempting me...

Have you ever evaluated TinyCore Linux? It's from the former developer 
of DSL (Damn Small Linux). On a modest Atom, it boots to a minimal 
desktop in about 7 seconds. Of course, it has almost nothing by default. 
The first thing you have to do is download packages of stuff you 
need.

Damn Small Linux 2.0 released..  http://www.damnsmalllinux.org/index.html


Damn Small is small enough and smart enough to do the following things:


    * Boot from a business card CD as a live linux distribution (LiveCD)
    * Boot from a USB pen drive

    * Boot from within a host operating system (that's right, it can 
    run *inside* Windows)

    * Run very nicely from an IDE Compact Flash drive via a method we 
    call "frugal install"

    * Transform into a Debian OS with a traditional hard drive install
    * Run light enough to power a 486DX with 16MB of Ram

    * Run fully in RAM with as little as 128MB (you will be amazed at 
    how fast your computer can be!)

    * Modularly grow -- DSL is highly extendable without the need to 
    customize

screen shots  http://www.damnsmalllinux.org/dsl-fb.2.0.jpghttp://www.damnsmalllinux.org/dsl-jwm.2.0.jpg

does rebol run on DSL ?

Visual Studio is getting DSL support, along the lines of what JetBrains 
has done I think. There's a team blogging about it inside MS, so 
I think Bill and Co. *do* think we need them (they're just doing 
it wrong ;-).

A "true" dialect in REBOL follows REBOL lexical form--i.e. you use 
block parsing--which is what would be called an embedded DSL in other 
languages. The concept is often associated with Lisp and its descendants. 
REBOL takes it furhter, and makes it easier (IMHO).

Thank Gregg. It's very helpful. DSL stands for Domain-Specific Language, 
right? http://en.wikipedia.org/wiki/Domain-specific_language

If I had to quickly pick an order;  REBOL, Forth, SNOBOL, Lisp.  
If I was told I HAD to do it in a class based object oriented language 
I'd probably pick SmallTalk ... no ... I'd probably just leave.  
To be honest, I've rarley seen a DSL that didn't require a programmer 
to script it anyway, so... I find the whole thing kind of moot.  
Moot is the wrong word.  A non-coder MIGHT be able to VID up a GUI 
but I doubt it would do much...or by the time they were done, the 
non-coder would have unknowningly become a coder.  I've not seen 
a DSL I'd turn over to Bob the manager to write progams in.  Even 
languages written to be specific; Erlang for telephony, Forth for 
telescopes, are still programmer languages. REBOL comes soooo close 
to being a data language that humans can use...but unfortunately 
nope;  Programmers required.  The magic all happens when you can 
build up layers, and stand on the shoulders of giants.  Something 
hardware engineers have been doing since day 1...programmers might 
learn by day 32'767 if we get lucky.  No doubt our smartest programmers 
will be fussing with strings 50 years from now with the same basic 
problems and mind sets faced 50 years ago.

In this context I am not going to offer the Curl examples for DSL 
and pass-the-proc except to say that ... no , I won't say that either 
;-)

I understand; my point was that mathematics, as a foundation, allows 
you to express things in a domain that Basque, historically, does 
not. A DSL doesn't *have* to be an extension or outgrowth of an existing 
language, but that can often help. In order for tha that to work, 
you need to choose a base language that suits your needs.

I've a notion to build a business rules parser in Rebol. But as a 
self-taught hacker with no background in computer science, I'd welcome 
any advice on flattening the learning curve. The docs cover the low 
level parsing details well enough, but I'm looking for enlightenment 
on the higher level issues involved in designing a little domain 
level language. Given that Carl is pushing Dialects as the Big Idea 
in Rebol, it's surprisingly difficult to find much on the topic in 
the Rebol community. Or am I missing something? I'd welcome any Rebol 
specific or generic resources to help me get up to speed on the whole 
DSL thing...

So, angular is a DSL that is compiled into JS client side to handle 
all the dom manipulation and other stuff that you would normally 
have to write JS to do ...or use Jquery functions.

Great example of a DSL Gregg.

The comma being disallowed as a word does mean you can't use it literally 
i true dialects, but that doesn't prevent you from writing a DSL 
and using string parsing. There have to be lines drawn somewhere.

Andreas:  for my particular case, I just asked why #"," isn't word 
as #"." is. I needed it to be word. And I am embeding that code/DSL 
with rebol code (It's not a separate file or string) so I can't string 
replace.


But I don't care, OK. I already used . instead and it's not perfect, 
but it's ok for me. I am just replying on what people here write 
( I think ).

Volker here is another example,



anyF: does [f g h
]

f: func[x][print "f third" 2 * x]

g: func[y][print "g second" y + 1
]
h: func[][print "h first" 1]


anyF ;; == f(g(h()))

;; 

now lets change 


g: does [print "g second" 5

]

anyF ;; == produces something like f(g()) h()


  anyF is compilable only if the order of evalutation 
doesn't change 
  at runtime. 

Rebol permits for the order of evalution to be determined 
  
by the context in which anyF is run, and the interpreter is 
smart 
  enough to GC the unconsumed values.


   This is a feature of Rebol because with the same expression 
you 
   can have two very different meanings, the disambiguation 
of the 
   grammar is provided by the context (or environment). 
This allow 
   Rebol to support easy Dialecting. That is each 
DSL may need specific 
   evaluation orders, aka semantics, 
while they share the same code 
   expression. In this case [f g h].



In the example above two different branches of the AST three 
were 
followed. But by just looking at [f g h] is impossible
to know which 
branch will be taken. 


  Other compilable languages enforce the order of evaluation by 
using 
  specific syntax forms to determine what is an expression. 
 Lisp 
  uses  parens, while  C semicolons and others markers.

 


So in order to make anyF compilable we need to  enforce the 
order 
of evaluation.  One possibilty  is to use Rebol parens.



anyF: does [(f) (g) (h)] ] *** see note


  The cost is evaluation speed for the interpreter, and now 
we are 
  back at using parens at each step. Which is what 
lisp uses. Should 
  we go back to 1967?


  The alternative of JIT is possible, but  it requires hinting and 
  
a sofisticated runtime environment. The translation of Rebol 
code 
  to some an  internal VM like rebcode  is simpler and maybe 
sufficient, 
  otherwise extending rebol via DLLs  is the way to 
get closer to 
  the metal. However, I don't see an easy path 
to having a Metacircular 
  Rebol. If you do, I hope you write
 a Rebol compiler and share it 
  with us ;-)

The http://www.bluishcoder.co.nz/2006/06/unenterprisey-languages-meeting.html
meeting was mildly interesting.  Robert Strandh showed how he reimplemented 
metafont in common lisp with the main aim that he could provide print 
services for his G# music score editor.  This was implemented as 
a DSL, and printing done by converting the DSL to postscript.  Familiar??

For writing a RIA research article, I've spent 10 hours studing Curl, 
that didn't make me an expert, but so far:

1. I like the content-centric programming, it's kind of like MakeDoc 
+ RSP + RTF.

2. The macro facility seems powerful, which makes homemade DSL possible, 
I guess.
3. APIs seem complete.
4. The 2D and 3D rendering engine uses hardware-acceleration.
5. It's a Functional Language.
6. Unicode, Yes, even Curl supports Unicode.

Like I said, I am not an expert, so any of the items listed above 
could be wrong. Here is a DDJ article http://www.ddj.com/dept/architect/184413224

I see that UNICON ( the language ) if yet to move to UNICODE in spite 
of its strong string handling and back-tracking features (co-routines, 
co-expressions)

There are remarkable similarities to REBOL ( ignoring its use of 
keywords such as &pos )
A recent variant is converge from Lawrence Tratt

Of course there is a big ISP named UNICON and someone has a DSL named 
UNICON

There is supposed to be a MAC version of ICON called PRO ICON ... 
I couldn't find it

My latest urban myth: that the name REBOL evolved from IDOL, the 
ICON pre-processor ( SNOBOL, ICON, IDOL, REBOL )

Baysick: a Scala DSL implementing basic: http://blog.fogus.me/2009/03/26/baysick-a-scala-dsl-implementing-basic/

Close, but no cigar. ;-)

Rebol and DSL's are hand and glove. Is there a SQL dsl anywhere? 
I found the driver from dobeash. Is there more?

I'm not sure if that would be worth the effort, SQL can get fairly 
complex and if a REBOL SQL wouldn't implement everything (even specific 
databases prorietary extensions to SQL) that wouldn't be a noticable 
gain in simplicity. Wouldn't it still just be SQL written in REBOL's 
syntax? Actually, I think it's more like SQL already is a perfect 
example of a DSL on it's own (not implying here that SQL is perfect, 
just the example is).

I have Suse, Puppy, Ubuntu, and DSL installed :)

No, other things... servers, ISP, DSL, kids, DTV, chicken, wine, 
etc.

here is an example of how we could use the unit system if it where 
implemented.


ANY unit moniker could be used, and in fact the switch tables below, 
could be context-specific and dialect-configured, adding to the DSL 
power of  REBOL... 


ex: dm could be decimeter or deutchmark (the later should be DM anyways, 
no?) , based on context, the convertion units could mean either or... 
with a default convertion table explicitely defined.

a simple func could let us append or change the conversion tables 
used throughout the system.  


Imagine if the VID would use units directly.  you set your locale 
(or get it from OS) and see values as they should be for your locality.


unit-convert: func [
	in "unit value to convert"
	to-moniker "to what unit type to you want to convert to"
][
	; note: incompatible types set 'IN to value none
	in/value: switch to-moniker any [
		switch in/moniker [
			{mm} [
				[
					{m} [in / 1000]
					{dm} [in / 100]
					{cm} [ in / 10]
					{'} [in * 0.0032808399]
					{"} [in  * 0.0393700787]
				]
			]
			{"} [
				[
					{m} [ in * 0.0254]
				]
			]
		]
		; empty result set, switch on nothing
		[]
	]
	in/moniker: to-moniker
]


unit-convert 100mm "m"
== 0.1m

unit-convert 100" "m"
== 2.54m

unit-convert 2mm  {'}
== 0.0787401575'

(sorry for not joining discussion earlier... I've been offline for 
almost a week due to my DSL modem going bust)

But you know, I woud prefer a DSL like emiter, something using parse's 
rules exclusively

I'm not sure I get your "DSL like emiter"? Do you mean compiling 
to an intermediate dialect, that would be compiled to native code?