newLISP Fan Club

Just to clarify, Rebel is very much alive. It's a hobby project, though, so I can't spend all my time working on it. I have a job, other interests, and life to take care of, too. My interest in the project hasn't faded at all — development just happens whenever I have the time and motivation.

There's no rush. 🙂

BTW I'm actually glad to see the community exploring different paths, whether it's Janet or the various newLISP forks. It's good to see people looking for ways forward rather than simply giving up on newLISP.

It has been down for more than 48 hours. Most likely both DNS and hosting were with the same provider and the service was not paid. The domain itself is fine.

Turbulent back and forth switching between (set 'sym ...) and (set sym ...) in an attempt
to find the right mental model and the paradigm shift.

set without quoted symbol name is the winner.

Summary:

set
  - Standard way to assign a value to a symbol/place.
    - (set a 1)
    - (set a 1 b 2 c '(3 4))
    - (set (nth 1 lst) exp)
    - (set f (fn (a b) ... ))
    - (set f (fn-macro (a b) ... ))
    - .. etc ...
  - Using a quoted symbol name is an error.
  - Replaces:
    - (set 'x 1) - error
    - (setf x 1) - primitive removed
    - (setq x 1) - primitive removed
    - (define x 1) - primitive removed

Purpose:
  - clear, direct symbol creation
  - no confusion anymore, symbol is never quoted
  - no ambiguity, sugars removed, can be aliased (alias 'setf set) if you want
  - no silent behavior

mut
  - *Opt-in*. You can use set all the time
  - Refers to a mutate operation.
  - Changes the value of an existing mutable symbol (created via set, let*, local).
  - Using a quoted symbol name is an error.
  - It is a visual marker for mutation.
  - It is meant for programmers who want to clearly distinguish in code
    where a symbol is created (using set, local, let*) and where it is later mutated (using mut).
  - It prevents quiet mutation of a symbol that was never created as a variable
    (e.g. due to a typo).
    (local (a b c)
       (mut a 1) ; OK: mutating an existing symbol
       (mut x 2) ; ERROR: symbol was never created in any scope (prevents silent bugs)
       (set x 2)  ; SILENT: creates or overwrites a symbol outside this scope as in newLISP
    )

tie
  - Works like newlisp set '
  - Unlike set, the name tie intentionally does not imply a standard assignment operation.
  - For now, intended for two special cases:

  1. When code generates another code containing at least one symbol assignment.
    - (map tie '(a b) '(1 2)) ... here map generates another code (tie 'a 1) (tie 'b 2)
    - (apply tie '(x 120))
    - macros
      (mac (defun _name _args)
        (tie _name (append '(fn ) (list _args) (args))))

  2. When a symbol points to another symbol, allowing indirect modification
    of the target symbol value.
    - (tie 'a 'b) (tie a 10) ... indirect assignment, b is 10.

  - I am not aware of any other cases where tie (and newlisp set 'sym) would need to be used.

  - Using tie in other cases:
    - is considered redundant/needless, use set instead.
    - will not be promoted in the manual as a standard assignment operation,
    - will be discouraged in the manual,
    - will never appear in Rebel ecosystem
    - is user's responsibility, it is not possible to disallow using tie in this way: (tie 'x 1)


func
  Creates a named function. Replaces define in this case.
  (func (f arg)) - OK
  (func f 1) - error, use set
  (func f (fn (arg) ...) - error, use set

If you want to try Rebel, please check the green checkmarks
in GitHub Actions before cloning. The repo moves fast
and may be temporarily broken.

https://github.com/ufko-org/rebel/actions


Ufko.

Hi.

Losing users who consider long function
names to be language expressiveness is,
in my view, an extremely drastic change.

Rebel is not a subject of discussion;
my post was only an announcement.

Ufko.

Hi,

Nothing broke functionally. Rebel keeps the same
language semantics; the changes are primarily in
function naming, not in behavior.

Rebel intentionally diverged to establish a concise,
more Unix/C-like naming for core functions.

There are two straightforward options for existing
newLISP code:

 - Rename function calls to the new Rebel names.
 - Define aliases for the original names.

Both approaches are fully supported and idiomatic.

The authoritative reference is primes.h, which
documents the active Rebel interface and naming.
See the header comment for orientation:

https://github.com/ufko-org/rebel/blob/main/src/primes.h

For renamed functions, the original newLISP name
can usually be inferred from the C primitive name,
which has not changed so far.

For example, new fwrite maps to p_writeFile, meaning
the original function name was write-file.

Regarding GitHub discussions/issues: they were disabled
intentionally to keep development focused.

Ufko

Rebel is no longer newLISP-compatible.
The break is mainly about function naming,
not features.
From here on, Rebel goes its own way.

Ufko.

TL;DR: From now on, set is the only way to assign or
mutate anything in Rebel. There is no separate
set ', setq, setf family.

Thanks for testing, Hapco.

You cloned a short transitional commit where the new
assignment semantics were already in place, but the
explicit error behavior was not yet implemented.

In Rebel, set is now the only assignment primitive.
Internally, set is equivalent to setf.

This means that assignments always operate on places.
Quoted symbols are not accepted as assignment targets.

Rebel v1.0 64-bit on BSD IPv4/6 UTF-8 libffi, options: rebel -h

> (set 'a '("hello" "there"))
ERR: quoted symbol used in function set

> (set a '("hello" "there"))
("hello" "there")
> a
("hello" "there")

Using (set 'a ...) is rejected by design. Everyone
who uses the (set 'sym ...) syntax in newLISP
has been doing it completely unnecessarily
the whole time.
Current versions emit a clear error in this case.

Until the new assignment semantics are fully documented,
the behavior of set can be considered equivalent to
the existing newLISP setf documentation.

Existing newLISP code that relies on the original
set 'symname, setq, or setf forms must be rewritten to
use the unified set form in order to run on Rebel.

As a temporary migration aid, it is possible to define
an alias for setf or setq, for example in
~/.init.rbl

(constant (global 'setf) set)
(constant (global 'setq) set)

Ufko

Thanks Carlos.
A real hardware test is important information for me!

One note about the current direction:

Rebel removes lambda completely.

If existing code uses lambda* symbols, you need to add your own aliases with
(constant (global ...)) or rewrite the scripts:

lambda is fn
lambda-macro is fn-macro
lambda? is fn?

define returns (fn ...),
define-macro returns (fn-macro ...),
macro returns (fn-macro ... expand ...),
macro? returns true for macros defined with define-macro or macro

Documentation will be updated later.
It is not a priority right now.

Ufko

Hey guys!

Rebel is now fully 64‑bit clean and Unix-native.
All the archaic cruft has been removed.

Windows support removed
Emscripten support removed
Legacy platform shims removed

New -q flag has been added
Init file is now ~/.init.rbl
(rebel -h)

All other functionality remains unchanged.

QA tests (qa-dot, FFI) run cleanly here:
Github Workflows
You can see Rebel running QA (qa-dot) test
on Ubuntu and macOS

For anyone interested in a lean,
Unix-focused swiss-knife interpreter,
this is the version to try

If you have questions, discuss here:
https://github.com/ufko-org/rebel/discussions

U.

Too bad you don't remember, maybe they're already solved by now
I've been using newLISP for a short time and hadn't worked with
any Lisp-like language before, so I'm a newbie, but those parens
really drew me in

My priorities are as follows:

1. fix all warnings under strict compilation, e.g., with -Wextra
2. create tests for built-in functions
3. create examples for new users
4. create/modify/rebrand documentation (markdown)

OK, Rebel v1.0 is out.

Clean build on OpeBSD 7.8 Lenovo x270
Clean build on Ubuntu Linux using Github Actions

$: rebel
Rebel v.1.0 64-bit on BSD IPv4/6 UTF-8 libffi, options: rebel -h

rebel: /home/ufko/me/c/rebel/src
main >
Buffer/Memory overflow warnings/potential errors eliminated.
Strings truncation warnings eliminated.
Ignored return values eliminated.
No linker warnings.
Lutz's Park & Miller algo in my_random() unused now.
C function random() replaced with arc4random() everywhere.

Build Report HERE

I believe Rebel v1.0 is currently the most stable incarnation of the newLISP codebase.
...

Thank you for your kind words, itistoday

Rebel runs on OpenBSD 7.8 and Ubuntu Linux.
For Linux test builds, I use GitHub Actions
(https://github.com/ufko-org/rebel/actions)
because I don't have a Linux machine.

I would appreciate it if someone could test it
on a real Linux machine and report the results:

1. Clone the repo
2. cd src
3. Run `make -f Makefile.linux`
4. Start `./rebel`



There are some compiler warnings and notes on Linux,
but I'm working on fixing them.

Hi guys,

I've forked newLISP 10.7.6 and made a few targeted changes:

    Removed compiler warnings
    Fixed or double-checked known bugs from the forum
    Refactored some internal structures for clarity
    Renamed files to match the new project name Rebel
    On BSD platforms, rebel-math.c now uses arc4random() for random numbers

Reasons for the fork, refactor, and renaming:

    Clear project identity 
    Wider adoption if it's not called newLISP 
    Less hate and flamewars 
    End of endless comparisons with LISP 
    Lutz had revolutionary thinking and was a rebel in his own way 
    Independence of development and ability to make internal changes 
    Better communication with new users 
    Motivation for contributors 
    Clear distinction for documentation, tutorials, and community

Just like most users, for example, don't perceive Clojure as a "new Lisp" but as a language with Lisp-like syntax that integrates smoothly into the JVM world, Rebel can be perceived similarly, as a Lisp-like tool that integrates smoothly with the C world.

It now runs cleanly on OpenBSD 7.8, 64-bit, UTF-8, with libffi support.

⚡gringo ~/me/c/rebel/src $: make
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel-symbol.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel-math.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel-list.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel-liststr.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel-string.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel-filesys.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel-sock.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel-import.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel-xml-json.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel-web.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel-matrix.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel-debug.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI rebel-utf8.c
cc -m64 -Wall -fno-strict-aliasing -O2 -c -g  -I/usr/local/include -DREADLINE -DREBEL64 -DSUPPORT_UTF8 -D_BSD -DFFI pcre.c
cc rebel.o  rebel-symbol.o  rebel-math.o  rebel-list.o  rebel-liststr.o  rebel-string.o  rebel-filesys.o  rebel-sock.o  rebel-import.o  rebel-xml-json.o  rebel-web.o  rebel-matrix.o  rebel-debl
ld: warning: rebel-web.c:1389(rebel-web.o:(handleHTTPcgi)): warning: random() may return deterministic values, is that what you want?
strip rebel

⚡gringo ~ $: rebel -n
rebeL v.0.1 64-bit on BSD IPv4/6 UTF-8 libffi, options: rebel -h

>

Functionality remains fully compatible with newLISP.

If you edit your Makefile contents, it should compile without problems.

I've bought the domain
https://rebel-lang.org

I've created an empty GitHub organization at
github.com/rebellang

For now, the repository is hosted under my account:
https://github.com/ufko-org/rebel

I fully respect GPL3 and Lutz's copyright.
Everyone is welcome to test the code.
Everyone is welcome to provide feedback, and share suggestions here in the forum for now.

And so I don't forget: scripts have the .rbl extension... Surprisingly 😄

Cheers, Ufko