Since I saw the "replace the entire stack" image, I expect no less than that the website should be made in Beads, hosted on a server running Beads OS, and the frontend should be WebAssembly compiled from Beads.
Beads was going to be recoded in Web Assembly, however, the many restrictions on I/O to the user's hard drive inside the browser make it very to build a compiler inside a browser. Hopefully in the near future Web Assembly will become a fully capable virtual machine, that will unify all the different hardware and operating systems, effectively becoming a universal virtual OS.
But any day now the dam will break, and WebAssembly will get access to I/O and the full browser API (last time i checked web assembly runs on its own compute-only thread, and is not permitted direct access)
many people, myself included, view Web Assembly has a future virtual machine that is universally available across hardware, ending the hassle of making specific executables for each operating system. A kind of improved P-Code system, if you are familiar with how UCSD Pascal worked (another brilliant Prof. Wirth project).
The loop syntax may appear unfamiliar, but since the core data structure of Beads is not lists, tuples, arrays, but instead a tree, there are various options that are more familiar to Lisp programmers, such as depth-first, or breadth-first tree traversal, but expressed as a loop, so you can conveniently stop it.
Most of the time one will use a loop in a very simplistic manner. Because it is so tedious and common to need the count of the loop, the key value, or a pointer to the element being looped across, we give you implied declaration capability in the loop consruct.
It is a compact notation that has gone through many polishing steps, and is very ergonomic, easy to read, and downright handy. Loops are the bread and butter of computer software, and yes, there are a fair number of options (such as going in reverse).
Please take the language for a spin, you might like it.
no, there is a typo in the video. The SDK is the best authority for Beads examples, as those are checked on each build for any errors. We have about 20 sample programs, some large enough to show most of the language features.
A lot of bold claims here. As someone who's worked on a lot of Excel business tools I can tell you there's no way something like this could replace anything in the companies I've worked for.
It looks like a functional(ish) reactive programming language, with an embedded database, and an SDK for compiling to JS and cross-platform binaries. Do I have that right?
Beads follows the State-Action-Model pattern, as described at sam.js.org. It is derived from the TLA+ work of Lamport. You have a mutable state, with pure code that renders the state on the screen, and then event tracking code mutates the state. What makes Beads unusual is that when you change the model, the screen layout section affected is automatically scheduled for refresh. This is possible because the state is being tracked
Compared to HTML/CSS/JS, Beads is much simpler. You can learn Beads in probably under 10 hours, while CSS takes at least 100 hours to master.
Most of the older popular languages like C, C++, Java, have huge external libraries you have to learn to make graphical interactive software.
So for the target application area, which is graphical interactive software, Beads is far simpler, and has many features to avoid error at compile time, and keep running with fault tolerance at execution time.
I am not aware of any bug in this code. It works, and the selection persists. Of course it is a silly project.
Classic FizzBuzz is just too simple a task to show off any language features, so the task was souped up so that it draws a 10x10 grid of the results, and lets you pick one of the 100 cells to highlight.
It persists this selection for a day to show how one can save up to 1kb of state information trivially inside the browser's cookie system, which is simpler to use than the IndexDB database (which is also available to use if you wish).
1Kb is enough to store a reasonable amount of data, and since Beads has a built-in graph database (not as fancy as Neo4J), you can store a subtree into the cookie with one line, and no encoding/decoding necessary, as that is performed by the runtime library for you (a nicety).
The convenience of working with a graph database internally, instead of the typical collection of data structures that one sees in older languages such as scalars, tuples, lists, dictionaries, queues, and pointers, is an advantage that only becomes apparent after some use of the language; i encourage you to take it for a spin.
That's neat, but imho start with the plain fizzbuzz first. Everyone has it in their lexicon so it acts as a first-pass Rosetta stone for what the language syntax is like. Adding extra bits implies you need those to get the job done.
I just updated the program to allow arbitrary arrays of words and factors for division, so now it is a fizz-buzz-jazz version of the program, and it gets even shorter once you go to table driven data.
var ss = ""
var color = ALICE_BLUE
loop across:WORDS index:wordx
if mod(b.cell_seq, PRIMES[wordx]) == 0
WORDS[wordx] &=> ss
color = COLORS[wordx]
if ss == ""
// plain cell
ss = to_str(b.cell_seq)
We need these kind of experiments. If you learn too much about contemporary software engineering, then it is almost certain that you'll end up with a React front-end talking to a NodeJS/Java back-end hosted on Kubernetes. Which is obviously the right thing most of the time :) but the world is richer because of these super-ambitious, super-naive experiments.
Also: imagine how much has someone learned from implementing all this.
You weren't richer but the worl might be. Sometimes clean sheets and first principles discover assumptions that have changed. Either in how people use software, how the domain itself works, or the constraints of computing.
I think that depends a lot on whether the failed startup produced any code, papers, conference talks, even podcast episodes, etc. If not, and everything was just buried in the person's head, then no, the world is not richer for it.
This kind of thing is why I'm so grateful to the founders of startups like Starsky, who are obviously still immensely passionate about the domain they were in. That even in the wake of the company failing, they've continued to advance the state of the art by sharing what they learned, especially where it's wisdom that goes against the current dogma (eg, that teleop is a hugely important part of a self-driving vehicle strategy, but that investors of the late 2010s were turned off by that focus because they wanted to see companies trying to shoot the moon on L4/L5 autonomy): https://medium.com/starsky-robotics-blog/the-end-of-starsky-...
My startup idea was to recognize objects by their shape. I got it to the point where I was able to setup an elasticsearch index that looked at point clouds uploaded and performed feature extraction on what was ingested. I haven't open sourced by code because I probably had committed API keys (but I should make it public now since all those keys stopped existing). The biggest issue was a large amount of debt and lost opportunity cost.
But it gave me a new perspective and at times it was really fun learning so much. I think it has made me a better developer because I made so many complicated mistakes and now I can simplify things.
Exactly. This particular iteration is going to fail miserably, but the world will be better because people are at least thinking like this. I hope that this idea happens, somehow.
Matter of perspective I admit but it also could just be a weird pastiche of elements of C, COBOL, M, Ada, and JavaScript. Nothing here seems particularly ambitious really.. idiosyncratic however. A good counterpoint might be Go.
The author used to at least actively solicit feedback, I never once noticed acknowledgement of any of it though.
User suggestions and bug reports are promptly followed up on. There are almost no known errors at this point, so it is very good shape.
You are correct that it has elements of JavaScript, but that is inevitable given that the primary output of the transpiler is JS code for use on the web, so some JS functions have to be present for that to work, and to inter-operate with JS, one has to use their string system.
The attempt to offer an integrated programming system, where we return to the simplicity of VB6, or Borland Delphi, is actually quite ambitious, as in order to offer such an integrated product one has to build in a database (graph in this case), a layout engine (novel, Renaissance proportion based layout model), a drawing system, and a way of coordinating between client/server (a novel subscription to a single source of truth system, with remote procedure calls).
The language is primarily based on Modula-2, which the author of Beads used for 20 years quite successfully in large commercial products. There is nothing from COBOL or Ada that i can think of (although Prof. Wirth did contribute to Ada I believe), not sure what the M language is. There are some elements of PROLOG built in that are not readily apparent, as the core programming pattern is State-Action-Model (see sam.js.org), and if you change a state variable, then any drawing code that used that variable is scheduled for refresh.
> but that is inevitable given that the primary output of the transpiler is JS code for use on the web, so some JS functions have to be present for that to work, and to inter-operate with JS, one has to use their string system.
I don't see why this is true (i also don't see it as a bad thing. Take what works and all that).
Probably, but I think that's also a little dismissive. Maybe they have received plenty of feedback but still think their ideas take precedence over that feedback. I don't think we should confuse outside-the-box thinking with thinking that hasn't received feedback.
they've received plenty of feedback from the PL community.
Beads is a fun an interesting project, but the over the top marketing language and hype is a bit silly. The author really is a rare mix of driven PL engineer and overly grandiose personally.
Funnily enough; the last time I tried something like that I was 25, had barely 6 months of experience, and somehow convinced a friend I had introduced to programming not more than two months earlier.
Waaay in over our heads.
Since then, I’ve realised it’s been tried and is being tried an inordinate number of times and seems to usually fail for some reason or another.
Kind of a wild goose chase for some (supposed) holy grail.
We had had a brush with AWS, it’s Lambdas, Step Functions, etc, as well as Zapier and Stamplay’s flow on our first project together.
We both came out of it convinced that there had to be a way to make it much easier yet still as powerful to orchestrate logic & services…
The goal was to make something we could use to drastically simplify the development of all our future endeavours, thinking we might also be able to sell it to others.
Nope. The guy posts with his real name on YouTube so this is like TempleOS and the creator is non anonymous, quite active on Reddit, and not very young (as if the style of graphics wasn’t a dead giveaway, like a time machine to the early 90s).
In any event I engaged with the creator before and what I can say is the conversations are entirely one-sided, in fact some of the most I have personally experienced. Will take one or two words from your post or reply, briefly mention it and then go completely off on a tangent only concretely related to those words. I’ve never known them to become outright offended or insulted and yet are completely impervious to any feedback. The upshot is, this will greatly limit a widespread following, because not all their tastes are exactly mainstream.
While I've not interacted with the author, his Twitter and blog opines on all kinds of subjects and has the firm, authoritative tone of an older person who is not exactly ignorant but who doesn't recognize the depth of his own indoctrination, the silencing of the internal critic. He has all the answers already.
And, really, that's the only kind of person that could make something of this encompassing but simultaneously incoherent nature, I think.
Have you read any of the reference manual? Why do you suggest the product is incoherent? it has been highly polished, and have written tens of thousands of lines of code in the language, and it works very well. A nice balance of concise vs. readable.
What indoctrination are you referring exactly? I don't understand the motivation for personal attacks on the author of a product you haven't even tried yet.
For those people who would prefer not to have to waste 100 hours of their time mastering CSS, the 10 hours it takes to learn Beads might be a better bargain.
It reminds me of the bold claims Paul Graham originally made about Arc. This website here is proof that at least something can come out of that, I guess.
It's very strange to me that the first pitch is that because desktops, laptops, and phones, are now all 64-bit, that is why we can now create a cross-platform language... that replaces scripting-ish languages.
I could understand if this was saying the 64-bit transition made things like Zig/Rust much simpler, but this seems like a non-sequitur for what Beads appears to be for.
I'm a little confused as well. A cross-platform language can work on any platform, like I can take my C++ code and run it on 64-bit or 32-bit, and this is true with plenty of other languages as well. I don't understand the relationship there at all.
From what I can tell, this language just transpiles into JavaScript, so technically it can run on any platform JavaScript runs on (except the transpiler itself, which I don't see why he didn't just write it in JavaScript as well).
The marketing effort here feels so unbalanced. On the plus side, there's a marketing video with a professional sounding voiceover. But then there's a website titled "Beads Language Home Site", with a barebones design, and which talks repeatedly about "Macintosh" and "Windows OS".
I apologize that the intro video is so much nicer than my own homemade videos. After paying a pro do to make that first video of a series of a dozen videos explaining the theory behind it, i realized it was going to cost too much, and the money would be better spent on the product itself.
So that video is just part of 1 of 15 parts, and with some support and enthusiasm from people, we can continue the series, because it is o much nicer to watch a professional video with proper British narration. As the great George Bernard Shaw once said, "The United States and Great Britain are two countries separated by a common language."
I hope that people will overlook the homwbrew quality level of the videos, but the language for a spin, because you might like the language a lot. It has a lot of simplifications, and particularly for client/server web apps, where it is much easier to build reliable products.
Rebol and is rebirth Red, is a very concise and powerful language. They are well funded, and will be a force to reckon with going forward. I would say the languages are very different in the sense that Beads is clearly aimed at graphical interactive software, with a layout/drawing/event model built into the language, while Red exists as a systems programming language, a variant customized for building crypto contracts, and then as a general purpose language.
They are so different that it is hard to compare. Red being a concatenative language has more in common with FORTH than Algol.
The closest thing to Beads is Elm, or visual javascript (was called Yazz)
(https://yazz.com/visifile/index.html), which is another integrated product.
I don't find Red particularly readable, it is a bit too dense for my taste. But some people will love it, and they have a very active Gitter group, and they are very nice people.
Red is the best funded language that i know of. Nenad did an initial coin offering (ICO) that was successful, and by my estimates will never have to work again. He has a good-sized team, and is building a very powerful product. Don't confuse his frugality with the financial independence he possesses due to his good timing at jumping onto the crypto bandwagon.
I don't know how you describe Rebol/Red. It a language made out of various subdomain specific languages, with a very unique syntax. It is very brief, and to me looking at it from a distance it more resembles FORTH or Postscript than any Algol derivative language.
Red has not prioritized graphical interactive products. I think its best subsystem is its amazing PARSE module, which is second only to Icon in text processing power.
There are other interesting projects like Enso, but they will probably run out of money, but i will wager Red will still be going strong 10 years from now.
It looks interesting. The reference card immediately made me think of the J vocab reference card (the old one, not the Nuvoc one!). I do like the declarative nature of beads, and it does remind me of Red or Rebol in a way as someone has already commented here.
There are more examples in the SDK, and the larger projects which have complex drawing going on, show the declarative layout system to its full advantage.
Probably the best liked feature of Beads is invisible in the syntax, as it follows the State-Action-Model pattern (see sam.js.org), and when a state variable changes, any layout that used that variable is automatically regenerated. This is of immense value when you have 500 things on the screen, and knowing which part of the screen to rebuild on any perturbation of the state is actually a lot of work, and the source of many under/over refresh errors.
This might be called a sprinkling of PROLOG's deduction system, where logical implication is done in the runtime. I am not aware of any top 20 language with deduction. The layout system is declarative like CSS, but includes variables, looping, and IF statements to make it more flexible.
The simplification that Beads offers is really only apparent in graphical/interactive software, and client/server programs. Otherwise people will stick to Python, etc.
So it's Basic for 99% of the overall programming, with something like CSS or Android's layout engine thrown in to solve the remaining 1%, specifically laying things out on a screen? Maybe you forgot to link to a convincing example.
I have been using it to travel forward in time, but am currently getting a 1:1 ratio with normal time so the forward time travel is not extremely apparent yet.
There are two aspects of time travel. The fancier one is time travel debugging. To use TTD, you run a program inside another. The outer program is called the monitor, and the monitor can freeze the inner program, and rewind the time back to some point. There is an API to do this, and examples showing how you have your own debugger. When you rewind, you can truncate the history and start fresh from that point onward. This is very useful for testing.
The second aspect of time control, the more simple one, is that you can jump the clock forward, and change the scaling of time at will, so that you can write tests to see if the alarm clock would ring as expected. That feature is as simple the std library functions that control the clock value and scaling. (set_clock_scale(), and set_clock()).
The ability to speed up time by a factor of 10 or 100 is a great time saver for those programs that have key sections, and slowing down time to 1/20th the normal rate (slo-motion) is wonderful for debugging animations. Many languages can set the clock, but not many have time scaling; a nicety.
Beads has a small standard library (compared to OSX or Java), but it has the key features you really need.
Beads is a tracked mutable state language. It used the State-Action-Model pattern (see sam.js.org), and is built from the start to support time travel debugging. Unlike `rr` and its sequel `pernosco`, it is not an instruction level reversibility, but a state change stepwise reversibility, which is efficient enough to stick around and be used in production use (not just in the lab).
There is a "blackbox_write' and 'blackbox_send" feature, which allows you to send session information sufficient to replay the user's session for debugging purposes.
This is a very powerful feature, and one that we are seeing more and more efforts to offer, because in a world with so many computers, being able to reproduce rarely occurring, data-dependent bugs, is very important.
And the example is weird: it explicitly explains you can do with fewer tests if the value is not true. Multiplication by N,U,ERR silently gives 0 as a result.
So multiplication by an ERR is not an error (from what I understand from quickly reading the ref).
The protected arithmetic rules in Beads are mostly a copy of the proven-to-be-useful protected arithmetic of Excel. Instead of using #UNDEF and #ERROR, those 2 meta values, are abbreviated U and ERR in Beads.
```
3 * ERR yields ERR
3 * U yields U (3 times undefined yields an undefined value)
```
The mathematical truth tables are in the appendix of the reference manual.
It is quite useful in a language to have a universal bottom value (undefined) and a universal top value (error). The key point is to avoid undefined behavior
Doesn't honestly seem that different from 'undefined' and 'NaN' in javascript and I think the fact that your 'NaN' is called 'ERR' is making people who think of errors as exceptions recoil.
(I'm not necessarily sure I like the trade-off you've chosen here, but I think the viscerally negative responses people are having are because of that, rather than thinking through the trade-off on its own merits)
In practice any JS programmer will find that the use of the undefined value is very familiar. In Beads it is abbreviated to U as it is used constantly, because the default value of something in the graph data structures is U.
For symmetry reasons, the error and undefined values work across all types, which cleans up one of the messes in JS, where you have undefined, NaN, null, and goodness knows what else. That we have a uniform error value for nodes is a very minor point; it is almost impossible to generate an error value in the protected arithmetic world of Beads. Square root of -1 is one of the only ways I can think of.
There is no try/except in Beads, there are no exceptions as all functions are total, and all arithmetic closed (like Excel).
I like this, the constructs in the ref card look really powerful, it looks like a batteries included language. Downloading it now to take it for a spin.
Edit: Nevermind Beads only works on Windows and Mac, It needs Wine to work on Linux.
if i can find a better cross platform delivery mechanism than AIR that isn't too far away from JS, i will switch, as there are a fair number of Linux-based programmers out there. Sorry for the current inconvenience of requiring Wine. But it does run okay according to some of my users.
Looking at the code examples I fail to see how this is a fundamental change from other full stack languages such as JavaScript, rust, C, C++, Nim.... The list goes on.
Not that that is a bad thing! I'm happy your working on it, but I don't think they or this will replace excel like tools until everyone decides to learn how to program instead of using an easy and familiar path.
It seems that after years of trying to develop programming languages and architectures to have separation of concerns, with the business logic, the presentation logic, and the data storage separated (or even going to full-blown microservices), this just... bunches everything together?
I get the appeal for a small program that fits in your head, but for anything more complex I don't want the code to take care of everything in a single module/file.
Meteor has a lot of users, and is still around. The problem with Meteor is that it uses JS, and that language has a lot of problems. Typescript has clobbered meteor, as people have realized that JS makes it far too easy to make a typographical error that crashes at runtime.
JS is still ahead of TS in usage according to the Tiobe Index and Github language commits. As far as typographical errors go, every already knew JS was a dynamic language, like Python and Ruby. I'd say other frameworks like React and Angular, or their predecessors out-competed Meteor.
The original promise of separation of concerns wasn't simply a code organization scheme, it was that we would be able to write composable software where components could be added or replaced with minimal systemic impact. We were going to be able to drop in new UIs without touching the BL or fix a bug in a component in one place and have it fixed everywhere, etc. The problem was that SoC, and the other various concepts from SOLID and design patterns didn't quite accomplish that - inter-dependencies remained and only became more difficult to reason about. Chasing this fantasy led object oriented programming down a path of increasingly complicated frameworks to try to manage and hide these dependencies until one would find themself thinking more about program structure and writing more plumbing code than doing actual work. Worse, now you have all the bits of logic necessary to understand how something works spread across multiple files so you have to have a system-wide understanding of a systems organization and understand the workings and vagaries of the half dozen or so different frameworks that were used to make it all seem magically loose-coupled. I'm sure there's some <insert name>'s Law somewhere that states it better, but it boils down to the fact that for any given set of tasks you can only reduce the complexity so much and anything else is just moving the complexity around, not eliminating it. I think there's something to be said for having all the logic you need to understand an interface in one or two files and focusing on making that as clean as possible, which is exactly what (at least some) of the 4GLs in the past seemed to do well, or at least made possible.
Beads uses the proven MODULE system of Modula-2 and Oberon. Of course we don't expect people to write in one single file. That the examples are small programs does not reflect the modular design of the language.
The entire purpose of the project is to build a world of software constructed by interchangeable parts. But to accomplish interchangeable parts, one has to make sure that there are as few external dependencies as possible, which is why the language has layout, drawing, event tracking, and database features pulled into the language, so as to not have one reaching outside, which would invariably break over time.
C proved that a standard library was a major feature of any language, and Beads has a well designed, but compact standard library, where you have a few functions, with lots of options so as to reduce the total number of functions one has to learn.
A lot of the authors verbiage is straight out of the 4GL talking points, so that's unsurprising. I agree it's probably a topic that is probably evergreen.
234 comments
[ 0.19 ms ] story [ 221 ms ] threadBut any day now the dam will break, and WebAssembly will get access to I/O and the full browser API (last time i checked web assembly runs on its own compute-only thread, and is not permitted direct access)
Portable generic VM (like the jvm but for anything), sure why not.
Having web browsers allow arbitrary access to hard disk? That's something else.
The index.beads and (I think!) corresponding index.html files are... quite something. I'm not 100% sure this will catch on.
The calculator example here makes rather more sense to me: https://github.com/magicmouse/beads-examples/blob/master/Exa...
[0] http://www.beadslang.com/downloads/refcard.pdf
Most of the time one will use a loop in a very simplistic manner. Because it is so tedious and common to need the count of the loop, the key value, or a pointer to the element being looped across, we give you implied declaration capability in the loop consruct.
It is a compact notation that has gone through many polishing steps, and is very ergonomic, easy to read, and downright handy. Loops are the bread and butter of computer software, and yes, there are a fair number of options (such as going in reverse).
Please take the language for a spin, you might like it.
https://youtu.be/4WYxAfX_fTw
It's definitely… interesting.
But this is supposed to replace Excel somehow? Along with basically every other language.
I can't accuse them of not being ambitious.
Most of the older popular languages like C, C++, Java, have huge external libraries you have to learn to make graphical interactive software.
So for the target application area, which is graphical interactive software, Beads is far simpler, and has many features to avoid error at compile time, and keep running with fault tolerance at execution time.
Classic FizzBuzz is just too simple a task to show off any language features, so the task was souped up so that it draws a 10x10 grid of the results, and lets you pick one of the 100 cells to highlight.
It persists this selection for a day to show how one can save up to 1kb of state information trivially inside the browser's cookie system, which is simpler to use than the IndexDB database (which is also available to use if you wish).
1Kb is enough to store a reasonable amount of data, and since Beads has a built-in graph database (not as fancy as Neo4J), you can store a subtree into the cookie with one line, and no encoding/decoding necessary, as that is performed by the runtime library for you (a nicety).
The convenience of working with a graph database internally, instead of the typical collection of data structures that one sees in older languages such as scalars, tuples, lists, dictionaries, queues, and pointers, is an advantage that only becomes apparent after some use of the language; i encourage you to take it for a spin.
Also: imagine how much has someone learned from implementing all this.
The world isn't richer if you listen to feedback quite the opposite it makes you improve what you are making.
I agree about the learning aspect but overhyping something doesn't really pan out that well.
This kind of thing is why I'm so grateful to the founders of startups like Starsky, who are obviously still immensely passionate about the domain they were in. That even in the wake of the company failing, they've continued to advance the state of the art by sharing what they learned, especially where it's wisdom that goes against the current dogma (eg, that teleop is a hugely important part of a self-driving vehicle strategy, but that investors of the late 2010s were turned off by that focus because they wanted to see companies trying to shoot the moon on L4/L5 autonomy): https://medium.com/starsky-robotics-blog/the-end-of-starsky-...
But it gave me a new perspective and at times it was really fun learning so much. I think it has made me a better developer because I made so many complicated mistakes and now I can simplify things.
The author used to at least actively solicit feedback, I never once noticed acknowledgement of any of it though.
User suggestions and bug reports are promptly followed up on. There are almost no known errors at this point, so it is very good shape.
You are correct that it has elements of JavaScript, but that is inevitable given that the primary output of the transpiler is JS code for use on the web, so some JS functions have to be present for that to work, and to inter-operate with JS, one has to use their string system.
The attempt to offer an integrated programming system, where we return to the simplicity of VB6, or Borland Delphi, is actually quite ambitious, as in order to offer such an integrated product one has to build in a database (graph in this case), a layout engine (novel, Renaissance proportion based layout model), a drawing system, and a way of coordinating between client/server (a novel subscription to a single source of truth system, with remote procedure calls).
The language is primarily based on Modula-2, which the author of Beads used for 20 years quite successfully in large commercial products. There is nothing from COBOL or Ada that i can think of (although Prof. Wirth did contribute to Ada I believe), not sure what the M language is. There are some elements of PROLOG built in that are not readily apparent, as the core programming pattern is State-Action-Model (see sam.js.org), and if you change a state variable, then any drawing code that used that variable is scheduled for refresh.
I don't see why this is true (i also don't see it as a bad thing. Take what works and all that).
Beads is a fun an interesting project, but the over the top marketing language and hype is a bit silly. The author really is a rare mix of driven PL engineer and overly grandiose personally.
Waaay in over our heads.
Since then, I’ve realised it’s been tried and is being tried an inordinate number of times and seems to usually fail for some reason or another.
Kind of a wild goose chase for some (supposed) holy grail.
We both came out of it convinced that there had to be a way to make it much easier yet still as powerful to orchestrate logic & services…
The goal was to make something we could use to drastically simplify the development of all our future endeavours, thinking we might also be able to sell it to others.
Little did we know how naive we were ^^’
That describes the state of things before every innovation in history.
I don't know how old he is, but there's enough grey hair there to know he's seen his share of things.
In any event I engaged with the creator before and what I can say is the conversations are entirely one-sided, in fact some of the most I have personally experienced. Will take one or two words from your post or reply, briefly mention it and then go completely off on a tangent only concretely related to those words. I’ve never known them to become outright offended or insulted and yet are completely impervious to any feedback. The upshot is, this will greatly limit a widespread following, because not all their tastes are exactly mainstream.
And, really, that's the only kind of person that could make something of this encompassing but simultaneously incoherent nature, I think.
What indoctrination are you referring exactly? I don't understand the motivation for personal attacks on the author of a product you haven't even tried yet.
For those people who would prefer not to have to waste 100 hours of their time mastering CSS, the 10 hours it takes to learn Beads might be a better bargain.
I could understand if this was saying the 64-bit transition made things like Zig/Rust much simpler, but this seems like a non-sequitur for what Beads appears to be for.
EDIT: didn’t finish reading your comment when replying, but it’s telling we both used the phrase non-sequitur
So that video is just part of 1 of 15 parts, and with some support and enthusiasm from people, we can continue the series, because it is o much nicer to watch a professional video with proper British narration. As the great George Bernard Shaw once said, "The United States and Great Britain are two countries separated by a common language."
I hope that people will overlook the homwbrew quality level of the videos, but the language for a spin, because you might like the language a lot. It has a lot of simplifications, and particularly for client/server web apps, where it is much easier to build reliable products.
Marketing: do a song & dance then pick style.
Engineering: just pick substance and get on with it!
[1] https://en.wikipedia.org/wiki/Rebol
[2] https://en.wikipedia.org/wiki/Red_(programming_language)
They are so different that it is hard to compare. Red being a concatenative language has more in common with FORTH than Algol.
The closest thing to Beads is Elm, or visual javascript (was called Yazz) (https://yazz.com/visifile/index.html), which is another integrated product.
Rebol Technologies went bankrupt, and Rebol is de-facto dead since more than a decade; Red barely manages to get by thanks to a recent crypto spike.
> I would say the languages are very different in the sense that Beads is clearly aimed at graphical interactive software.
So is Red with it's native GUI engine. [1]
> Red exists as a systems programming language, a variant customized for building crypto contracts, and then as a general purpose language.
"Domain-specific languages" is the term you are looking for.
> They are so different that it is hard to compare.
Both share the same goal of replacing modern software practices with biased, batteries-included toolchain, varying only in implementation.
> Red being a concatenative language has more in common with FORTH than Algol.
Red is not concatenative in any sense of the word, nor any other language in Rebol family that I know of.
[1]: https://github.com/red/docs/blob/master/en/view.adoc
Red is the best funded language that i know of. Nenad did an initial coin offering (ICO) that was successful, and by my estimates will never have to work again. He has a good-sized team, and is building a very powerful product. Don't confuse his frugality with the financial independence he possesses due to his good timing at jumping onto the crypto bandwagon.
I don't know how you describe Rebol/Red. It a language made out of various subdomain specific languages, with a very unique syntax. It is very brief, and to me looking at it from a distance it more resembles FORTH or Postscript than any Algol derivative language.
Red has not prioritized graphical interactive products. I think its best subsystem is its amazing PARSE module, which is second only to Icon in text processing power.
There are other interesting projects like Enso, but they will probably run out of money, but i will wager Red will still be going strong 10 years from now.
Probably the best liked feature of Beads is invisible in the syntax, as it follows the State-Action-Model pattern (see sam.js.org), and when a state variable changes, any layout that used that variable is automatically regenerated. This is of immense value when you have 500 things on the screen, and knowing which part of the screen to rebuild on any perturbation of the state is actually a lot of work, and the source of many under/over refresh errors.
This might be called a sprinkling of PROLOG's deduction system, where logical implication is done in the runtime. I am not aware of any top 20 language with deduction. The layout system is declarative like CSS, but includes variables, looping, and IF statements to make it more flexible.
The simplification that Beads offers is really only apparent in graphical/interactive software, and client/server programs. Otherwise people will stick to Python, etc.
I'm I the only one who sees the irony in this statement?
The second aspect of time control, the more simple one, is that you can jump the clock forward, and change the scaling of time at will, so that you can write tests to see if the alarm clock would ring as expected. That feature is as simple the std library functions that control the clock value and scaling. (set_clock_scale(), and set_clock()).
The ability to speed up time by a factor of 10 or 100 is a great time saver for those programs that have key sections, and slowing down time to 1/20th the normal rate (slo-motion) is wonderful for debugging animations. Many languages can set the clock, but not many have time scaling; a nicety.
Beads has a small standard library (compared to OSX or Java), but it has the key features you really need.
0. https://rr-project.org/
There is a "blackbox_write' and 'blackbox_send" feature, which allows you to send session information sufficient to replay the user's session for debugging purposes.
This is a very powerful feature, and one that we are seeing more and more efforts to offer, because in a world with so many computers, being able to reproduce rarely occurring, data-dependent bugs, is very important.
So multiplication by an ERR is not an error (from what I understand from quickly reading the ref).
``` 3 * ERR yields ERR 3 * U yields U (3 times undefined yields an undefined value) ```
The mathematical truth tables are in the appendix of the reference manual.
It is quite useful in a language to have a universal bottom value (undefined) and a universal top value (error). The key point is to avoid undefined behavior
(I'm not necessarily sure I like the trade-off you've chosen here, but I think the viscerally negative responses people are having are because of that, rather than thinking through the trade-off on its own merits)
For symmetry reasons, the error and undefined values work across all types, which cleans up one of the messes in JS, where you have undefined, NaN, null, and goodness knows what else. That we have a uniform error value for nodes is a very minor point; it is almost impossible to generate an error value in the protected arithmetic world of Beads. Square root of -1 is one of the only ways I can think of.
There is no try/except in Beads, there are no exceptions as all functions are total, and all arithmetic closed (like Excel).
Edit: Nevermind Beads only works on Windows and Mac, It needs Wine to work on Linux.
Not that that is a bad thing! I'm happy your working on it, but I don't think they or this will replace excel like tools until everyone decides to learn how to program instead of using an easy and familiar path.
I get the appeal for a small program that fits in your head, but for anything more complex I don't want the code to take care of everything in a single module/file.
The entire purpose of the project is to build a world of software constructed by interchangeable parts. But to accomplish interchangeable parts, one has to make sure that there are as few external dependencies as possible, which is why the language has layout, drawing, event tracking, and database features pulled into the language, so as to not have one reaching outside, which would invariably break over time.
C proved that a standard library was a major feature of any language, and Beads has a well designed, but compact standard library, where you have a few functions, with lots of options so as to reduce the total number of functions one has to learn.
I think this concept will be revisited from time to time in the future, although I agree with the skepticism about this particular project.