I would seriously consider toning down the marketing speak. This project is making very bold claims, without citations, while trying to appeal to an often skeptical crowd (developers).
"Graph databases are considered more powerful and modern than relational databases," ... okay? According to what benchmark and for what workloads? A statement like that is an immediate turnoff because it is dismissive of 30 years of database development.
"In many languages the slightest error in input data can cause a program to seriously malfunction. Beads has special rules of arithmetic and a robust mathematical model, that makes it extremely difficult to have a serious malfunction." I don't see how "special rules of arithmetic and a robust mathematical model" makes it "extremely difficult to have a serious malfunction."
Replacing "Unix, SQL, Rails, Ruby, RSpec, Templates, HTTP, HTML, CSS, DOM, jQuery and Javascript" in one language? How does this replace Unix? HTTP? It's not an operating system or a transport layer.
My goal isn't to crush someones idea, but consider your audience: developers.
Honestly, i think graph db being more powerful is one of their more reasonable claims. Graph db trade off a more flexible data model (which some people would call power) against performance/scalability.
Whether or not that's a good trade off in your domain is a very different question.
Edit: although based on the docs, the graph db seems roughly a data structure where nodes can point to each other (i dont see anything about complex queries, or managing concurrency, or even persistence). By that definition, i think even c would be a language with an embedded graph db (structs and pointers)
Neo4J has a souped SQL language they call Cypher to perform queries. But since Beads data structures are typically arranged in tree form, one typically uses the loop construct to interate across them, as one is often drawing them. To that end, Beads has a fairly elaborate loop construct, with the ability to traverse 1 or 2 dimensions at once, or do a recursive descent traversal.
In a graphical programming environment one is really listing and drawing the content for editing, versus making a list of something.
You can send subtrees across the wire conveniently, subscribe to a remote machine's subtree, etc. and you can write to the hard drive the trees.
However concurrency is not really present in the system as i am emitting JS which is a single threaded system for the most part. So Beads has almost zero concurrency support at present.
> Honestly, i think graph db being more powerful is one of their more reasonable claims. Graph db trade off a more flexible data model (which some people would call power)
You can represent graphs in the relational model so that’s simply bullshit.
Neo4j had a great demo, load up the IMDB database, then solve six degrees of Kevin Bacon with SQL vs with Cypher. The Cypher is a one liner that runs immediately, the SQL is a mess that almost brings down the database.
For certain types of queries, recommendation engines being a prime example, graph databases are awesome.
For one, Neo4j is an implementation and SQL is not. As for clarity, SQL, although by far the most widespread query language is a shitty language in many respects... again a separate issue from the relational model.
In any case you’re conflating a storage engine and a query language. There’s no reason an RDBMS implementation cannot be tuned for graphs, and there is no inherent lack of generality in the relational model which seems to be the prior posters claim. Whether Neo4j is a useful piece of software is a different topic.
Infinite self-joins are not elegant in relational algebra. They are very not elegant in SQL (recursive CTE's are soo ugly). Last of all, they are super inefficient in almost every RDBMS.
> Infinite self-joins are not elegant in relational algebra.
Somewhat ironic comment given the name of this site.
SQL stinks as a language in many ways, won’t argue there. However for many cases even PostgreSQL does just fine with recursive CTEs (though granted when it fails it does so hard). Oracle does better (and CONNECT BY has been around for over 40 years - someone’s been getting by with it). Graphs in RDBMSes are not uncommon.
Anyway, none of this has anything to do with the original claim. Are graph db implementations useful? Definitely (though often times sticking with the rdbms is the better choice). But they get their utility by being less flexible.
Hi, I would like to chime in here on your comment on the marketing speak of the Beads project. I know the author of Beads, and was happy that he gave me a shoutout for my own project, Visual Javascript. Anyway, I have been following this new coding space for a while and I was also the initial angel investor for a project called Eve (the follow up for Light Table) which was an excellent project made by someone called Chris Granger (https://news.ycombinator.com/item?id=12817468). Anyway, I agree that the presentation of the Beads language could be improved massively, but the Beads language itself has some very interesting features, so should not be ignored. I think reading through all the comments on this hacker news thread it would be very useful to know what parts of Beads actually interest readers, and how they would present/market Beads themselves if it was their own project. This could be very constructive. For me personally it is the time travelling debugger that it interesting in Beads. What is it about Beads that you find interesting?
I am vaguely familiar with Light Table and Eve (coincidentally my college roommate grew up with Chris but I don't know him personally). It's been awhile but my recollection is Light Table/Eve had a more targeted set of selling points -- a killer IDE with some slick features I hadn't seen before and then a new language designed to be written as prose.
Regarding Beads: time travel is definitely a cool feature. Most languages have some kind of step debugger but the experience can often be improved. Having a built in graph DB could be an interesting selling point too. I'd love to see a quick example of what having a graph DB built into the language enables. For instance, this post https://news.ycombinator.com/item?id=27315018 cites a Neo4j demo that, in a few lines of code, shows me something their product does "better" than SQL. I would love to see, on the Beads front page, a small (5 lines max?) code blurb that shows me something Beads can do harder, better, faster, stronger (or whatever ;) ) than other languages. I don't quite know what that is, but I imagine the author has some thoughts :).
> I don't see how "special rules of arithmetic and a robust mathematical model" makes it "extremely difficult to have a serious malfunction."
The only way would be to have arbitrary precision integers by default and thus no overflows ever. (IIRC smalltalk was something like that, but it was long time ago since I used it, so I'm not sure)
Integer types in current versions of Ruby and Python both have arbitrary precision (as is also true for lots of other languages these days). That's not enough to make either intrinsically bug-free...
python does have bignum integer, but there are subtle things, like if you divide an integer with an integer you get a float, where you do lose precision:
bignum as the default integer is quite common in lots of languages[1]. Notably, Lisp, Scheme, Erlang, Python.
Scheme is a bit interesting in that they have a "numeric tower", which contains rationals and even complex numbers (implementations were free to implement a subset of this tower, at least as far as R5RS, not sure today)
Just to elaborate a bit, in CL, numbers are FIXNUMs by default but are promoted to BIGNUMs if needed. CL also has rational and complex numbers, which it probably got from Scheme but I'm not familiar with that history.
Excel achieves its robustness (and it hardly ever crashes) by protecting the user against arithmetic errors, and circular reasoning. Excel doesn't offer infinite precision arithmetic, that is rarely needed in practice.
Null pointers are something that plagues Java, which are primarily caused by having some computation out of sequence. By using the State-Action-Model pattern, most of Beads code will be devoted to rendering the model on the screen, and that one-way transfer of information can be made very robust, provided you have a closed arithmetic, which it does.
That's definitely one way to solve the issue, but I wouldn't say it's the only way.
In Rust, you can configure Clippy to ban the usage of +-*/ and require explicit behavior of each calculation. For example, 10u8.checked_add(10) returns an Option<> (similar to Maybe in Haskell) so you can handle overflows. You can also use 1u8.saturating_sub(100) which will not allow wraparound but values will saturate at the max/min.
Beads is like VB6, and Oracle Delphi, an all-in-one language that shields you from the complexities of learning all these external tools and having to learn so many languages. To someone whom i guess a long-time developer, you might dismiss it as too simplistic for your purposes.
For example you can skip using Unix Bash and use Beads like Python as a scripting language. You can build a very nice client/server product like the "Robin Hoody" app, using the publish/subscribe functions built into the language without ever learning how to encode/decode a packet, as the runtime makes it easy to do this. So in that sense the language does offer a virtual transport layer.
Sure, you may need to drop down and encode/decode a websocket message buffer, but the point of Beads is to permit writing in a single language, without having to learn CSS and the whole pile of complexity that accompanies modern development. You can't make an easier stock quoting system (one of the examples), because it has been reduced to the absolute minimum number of lines.
The protected arithmetic of Excel is of proven utility, and i am merely imitating it. I replace #UNDEF with U, and #ERROR with ERR to make it less verbose, but protections abound in Beads both at compile time, and at runtime. In a graph database universe, you don't need scalars, tuples, lists, dictionaries, queues, hashmaps, etc., because a single more general data structure accomplishes that you need.
Graph databases are quite hot; Neo4J has grown leaps and bounds, and Oracle was forced to come out with one. I am sure that most existing systems continue to use older tech, because that is always how it goes in computers. People are still running COBOL in some places, because it is so damn fast and works perfectly at what it was built to do. I have no doubt that we will see existing tech which works fine continue to be used for another 50 years.
It makes sense to make an easier environment that is still capable, but much simpler to learn and use, and that is the goal of Beads.
As for the skepticism of crowds, my product is out there, and has no major bugs in it, and hopefully will find an audience that likes this approach.
How you present your ideas are as important as the quality of your ideas. My suggestion is that your website's presentation does not present your ideas in a way that is likely to reach your target audience. That's an opinion of course.
Your comment clarifies that you aren't claiming to replace UNIX but that you can use Beads as a general scripting language. Consider updating the big graphic on the front page that says UNIX to Say Bash (sh, zsh or whatever).
Lastly, your response is selling me on graph databases, but I never objected to graph databases as a technology, just your bold statement about them with no caveats or citations. Saying, "graph databases are considered more powerful and modern than relational databases..." is a good way to start a flame war but not a good way to convince someone to use your product.
All that being said, best of luck with your project! I do mean that sincerely.
"Graph databases are considered more powerful and modern than relational databases" vs. "Graph databases are quite hot"
These two statements are in no way equivalent.
I see what GP was complaining about. Even your opening para graph contains a fair bit of confusion. It reads like you are suggesting imperative languages were succeeded by object oriented, which were succeeded by functional in 'generations' - which is already incorrect on a couple of fundamental levels - and now the time is "ripe" for a "new paradigm" called declarative. Which is a language classification that has been around since nearly the beginning (first thing it makes me think of is Prolog, e.g. 1970s). So is this new or old?
This followed by a couple of pretty silly sounding assertions "almost no bugs" "10:1 reduction in life-cycle costs" which unsurprisingly are not supported.
Then we have the last sentence "For many graphical interactive or client/server applications, you can replace the entire development stack with one relatively simple tool.". Isn't that what you really want to convey?
When you get off on the wrong foot like that it's not hard to see why you've had some of the responses you have had. If you replaced the entire first paragraph with that last sentence you'd be far better off; the rest is poor communication, just getting in your own way.
okay i have rewritten parts of it. I hope you folks take it for a spin; it has a lot of nice touches in it; worked very hard on the balance between concision and readability.
I don't see similarities with COBOL other than Beads has a low percentage of punctuation, but that is from imitating Python's indent-significant code structure style.
COBOL generated a lot of billable hours. I did early years in my career as a consultant-for-hire in a SF body shop, and occasionally would have to fix some COBOL thing. I sure hated it. Woke up one day in a puddle of drool from passing out because of boredom, and then switched jobs.
Beads is from a word-count metric, is probably within 20% of the minimum word count for the sample programs i presented, if you exclude techniques that greatly obfuscate the logic such as those used in Oscar Toledo's famous chess program.
Substitution and concatenative languages like FORTH regularly win code-length contests, but they aren't very readable. Beads tries to find a happy medium between brevity and clarity. I think people writing it will enjoy the careful balance that was struck.
No offense, but that's the most BS sounding pitch i've ever heard.
You're fixing the garbage-in, garbage-out problem? Have you also invented strong AI and solved the halting problem?
Edit: you should replace your website with the first page of your language reference pdf. That's a better pitch and more interesting than anything you've written here.
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.
Yeah color me skeptical. I love experiments, but I prefer those that under-promise and over-deliver. People have been promising unification languages since there were only two languages. People have been promising cross-platform since there were two platforms. And people have been promising to replace Excel since...Excel
The thing that really bothered me was the FizzBuzz example [0]. The core logic is:
cell
// this routine will be called 100 times, and the implied block variable
// b will hold values, like the sequence number b.cell_seq
var ss : str
case mod(b.cell_seq, 15)
| 0
ss = "FizzBuzz"
draw_rect(fill:LIGHT_SKY_BLUE)
| 3, 6, 9, 12
ss = "Fizz"
draw_rect(fill:LIGHT_GREEN)
| 5, 10
ss = "Buzz"
draw_rect(fill:YELLOW)
else
ss = to_str(b.cell_seq)
draw_rect(fill:ALICE_BLUE)
// we just set the string in the case statement above
draw_str(ss, size:0.7, color:BLACK)
// if this is the selected cell, highlight with a red frame
if b.cell_seq == my_state.selected
draw_rect(thick:3 pt, pos:0.7, color:CRIMSON, corner:2 pt)
The entire point of FizzBuzz, as a programming practice, is to ensure the programmer does not try to write this exact code: you check mod 3 and print Fizz, mod 5 and print Buzz. This "solution" makes me worry the language itself will impede the simple solutions.
> The entire point of FizzBuzz, as a programming practice, is to ensure the programmer does not try to write this exact code
No, the point of FizzBuzz, which is an interview practice is to make sure that the candidate has literally the minimum ability to translate a natural-language problem description into code.
There is no point using it for anything else. Not demos of languages or tools, not looking for a particular shape of solution, you don't even really need to let them finish writing a bug-free version of it. It is only to filter out the people who "learned a language" but cannot actually write a program. Which is unfortunately a ton of people.
I agree that I hate this solution. However, are you saying that this is a bad FizzBuzz solution to you? (Python)
nums = list(range(100))
def fizzbuzz(n):
if n % 15 == 0:
return "FizzBuzz"
elif n % 3 == 0:
return "Fizz"
elif n % 5 == 0:
return "Buzz"
else:
return str(n)
print(" ".join(map(fizzbuzz, nums)))
I think it's far better than:
nums = list(range(100))
for num in nums:
if num % 3 == 0:
print("Fizz", end="")
if num % 5 == 0:
print("Buzz", end="")
if num % 3 != 0 and num % 5 != 0:
print(num, end="")
print(" ")
I don’t want to argue in favour of the Beads solution but I think the right way to describe the logic is as follows:
input is n
| 3 divides n | 5 divides n | result |
|—————————————|—————————————|————————————|
| Yes | Yes | “FizzBuzz” |
| Yes | No | “Fizz” |
| No | Yes | “Buzz” |
| No | No | n.toString |
print result
The key points are:
1. The logic is declarative: the order of the rows in the table doesn’t matter.
2. It tests for divisibility in words rather than a potentially confusing idiom (how does % behave for negative numbers? Is it defined for floats in this language?)
3. The structure allows you (or a compiler) to check that no case is missed.
4. It should be easier to convince oneself that modifications to the code do what they are supposed to.
The funny thing is that looking things up in tables is much more common in excel.
At the risk of the classic "no here's the fizzbuzz code" while then getting it wrong, the typical case you're trying to draw out is like the second but:
Not printing in the middle, return a string and afterwards print it.
Each step adds to the string, and if it's still empty by the end you just put the number in.
The next stages are often to add another number, then something more complex (if it's a prime number). As you do this, the concatenation version grows slowly while the first approach explodes in combinations.
In his defense: I think the logic of his programming language and the pattern match works just fine: it's a mod over bounded linear range checking a remainder. He's just showing off that he can check "mod 15" against a list of potential values, or at least that's my reading of it.
> is to ensure the programmer does not try to write this exact code
I agree with your thoughts around the language constraints, but I see more room for what you once could have gotten from using FizzBuzz as a minimum-skill filter. It depends on the level you're hiring at.
From a novice engineer I would be content if they're demonstrating awareness that multiples of 15 represent an edge case without it being included in the instructions.
If I'm hiring someone more senior, I'd expect them to provide (or iterate to) a more optimized solution to FizzBuzz.
But in a further tangent - I think this using this type of question as a minimum-talent filter stopped becoming viable as soon as it became commonly used. In the time since, it's become more a minimum-knowledge filter -- and that doesn't tell you anything about the candidate's methods in solving a problem with derivable requirements.
There are about 3 slightly different methods for doing FizzBuzz, in any language, and this was but one of them.
You could express it also as an empty string, then concatenating as necessary:
'''
// to those objecting to using a modulo-15 test,
// we could have done the above code as follows:
var ss = ""
if mod(b.cell_seq, 3) == 0
"Fizz" &=> ss
if mod(b.cell_seq, 5) == 0
"Buzz" &=> ss
if ss == ""
ss = to_str(b.cell_seq)
'''
The problem with FizzBuzz as a programming language exploration is that it is far too short of a program to reveal the totality of a language, since it only consists of using the if/pattern match capability, modulo function, concatenating strings, and converting an integer to a string. The Stock market ticker program is a much better demo of the language, because it shows how to do client/server programming in a very easy way.
I think that is a better FizzBuzz example. You are right that it isn't meant to showcase the whole language, but lacking a composable solution (mod N1 || mod N2... for N prime factors) makes me immediately think the language does not lend itself well to that kind of composition.
And as others mentioned, Fizzbuzz is merely a "can you program anything test." But I do prefer the "general" fizzbuzzjazz, which accepts a list of numbers and a list of words [fizz, buzz, jazz,...] and emits the strings for appropriate prime factors.
My preference is to have all behaviours be explicit in the declared code, rather than implicit or as a side-effect. Much simpler to read and reason about the program.
Clarity over cleverness. To that end, I prefer this version over 'hiding' the mod 15 case for the sake of saving a line of code.
I also appreciate languages that warn (or better, require) that all cases are covered.
I think he's saying that inside of the loop in FizzBuzz, it should look like something like this (Python-esque pseudocode, assuming for a second print() doesn't add a newline automatically):
if x % 3 == 0:
print("Fizz")
if x % 5 == 0:
print("Buzz")
if x % 3 != 0 and x % 5 != 0:
print(x)
print("\n")
i.e. no special "FizzBuzz" case for when it's divisible by 15, it just naturally falls out of the first two if's. It's a bit of a silly objection though, the it's fine to write it as the author did.
A lot of the rosetta code examples show the simple and the more complex example or less use of built-in functions to show they can express it with the core language.
Beads does not replace Excel, but it can close the gap between Excel and the popular programming languages, which have a great deal of unnecessary complexity in them. For example, in HTML/CSS/JS, the comment syntax varies between the 3 languages. Why are there 3 distinct languages in one source file? When in history was this ever done? I can remember mixing 2 languages, but 3? that's just ridiculous.
Code which doesn't execute has very few bugs in it in my experience. And those bugs tend to be easier to fix, than say a register clobberation bug in assembly language which i have had to wrestle with before. Telling the computer what to do, but not telling it how, does cut out a lot of effort (and potential errors).
You have every right to be skeptical, but i hope you can overcome your initial skepticism to at least take it for a test drive.
The layout system is declarative (with escape hatch to looping and conditionals), and so is the finite state machine syntax DSL inside, and the regular expression syntax (a novel reformulation).
But the nicest feature, invisible in the syntax because it is a property of the runtime under the hood, is that when you change your mutable state, any layout that used those variables is automatically scheduled for refresh. You thus declare what is on the screen, and how it is arrange, and the system knows what to do. In this sense it more like SQL, where you give it a goal, and don't specify the ordering of how to achieve the task.
There are also mini-solvers built into the language for the common tasks of solving for rectangles and points, which are quite handy.
I don't think having an embedded DSL for defining layouts makes it a declaritive language. By that definition, almost every language is declarative as its a somewhat common way to define layouts (certainly not universal, but common enough that i suspect every language has at least one library that supports it).
If the main facilities for writing logic in the language are procedural, than i'd call that a procedural language.
That one piqued my attention. It's one thing to say "fewer bugs" and quite another to say "almost none". Rust is a declarative language with one of the more rigorous static analysis checkers (for pedants: among mainstream languages) and I still write buggy code.
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.
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).
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.
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.
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)
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.
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.
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.
I think this project is really cool and am disappointed by so many of the negative sounding comments. They kind of remind me of the infamous Dropbox comment.
I think some healthy skepticism is fine but the mockery and out of hand dismissals seem like they should be beneath this crowd.
I think you have the wrong takeaway from this thread. The project marketing is terrible, it is confusing, lacks focus, makes senseless claims, and doesn't showcase the project's strong points. People are telling the author where his marketing is falling short, and the developer has already updated his marketing in a few places to make it better. What you're watching is improvement in real-time.
I have the opposite impression as you. Honestly, you're one of the only people in this thread who engaged with the author in a respectful way, and I thank you for that. I agree with you that the author needs to do some work on the marketing side, and the helpful pointers provided here by you and others will hopefully move him in that direction.
Still, there are others in this thread who should be ashamed of themselves. We have people implying the author is childish, outright calling him disrespectful, calling his project a joke and a parody... it's all really quite sad. I mean, here you have a guy who has put years of work into a project, who embodies the hacker ethos, and a community of self-described hackers can't push past his lack of marketing ability to engage with the technical merits of this diamond in the rough. Set the marketing on the main page aside, and you have a 136 page technical reference (linked helpfully on the front page) that contains a lot of great info. Yet the closest anyone came to engaging with it here was to complain that it's a PDF.
Which baffles me to some degree. You'd think this community, of all communities, would be welcoming and inquisitive when confronted with strange new ideas, despite bad marketing. The community is not just technically focused, but built around a startup incubator whose founder warned of this exact dynamic! And yet all we seem to get is superficial discussion related to marketing.
So at risk of being the exact type of crusty old guy the tweeter is complaining about, I think Rik is completely missing the point. Progammers are busy, and not just with work but with learning. Somebody said its a 60hr/wk job, 40hrs for your boss and 20hrs just keeping up with technology, and while probably a bit facitious most weeks it feels that way. So not only are we keeping up with the platforms we're working on, we're also trying to keep an eye on what technology is on the horizon, or even other technology that exists and is usable today that we probably should know about.
Rik sounds like somebody who applies for 100 jobs and complains why companies never give him feedback without realizing that each of those jobs is getting 100s of applications and replying to them all is not remotely possible.
Then further, his market is developers who have been around awhile and seen some shit. This is an industry where everything old is new again; the reason people have a knee-jerk reaction to projects like Beads and Makepad is because we've seen things that look similar, probably used them ourselves, and been burned by them. People working on projects like this, when they are marketing to experienced developers, should try and place the project in the context of the history of similar projects and explain why this time they have it right.
Lastly, it doesn't matter if your project is asking for money or asking for developer attention, insulting your target market is never the right play. Startups spend massive energy honing and refining their marketing message, they don't expect potential customers to just magically get-it. Projects who want developer attention should view their marketing with the same importance. And if a project, just like a product, does not take their marketing seriously, I'm less inclined to take them seriously unless they are very clearly and obviously solving one of my immediate problems at which point I don't care if their marketing is a plain text document.
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.
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.
"Some people, when confronted with a problem, think 'I know, I'll u̵s̵e̵ ̵r̵e̵g̵u̵l̵a̵r̵ ̵e̵x̵p̵r̵e̵s̵s̵i̵o̵n̵s̵ invent a new programming language that will unify everything.' Now they have two problems."
Funny you should mention Regular Expressions. In Beads there is a complete rewrite of the syntax for regular expressions, replacing the meta characters with a more readable vertical format that facilitates comments, and offers subroutines. For example, compare the IPv4 address regular expression as done in JS:
The Javascript version is extremely hard to read. I can't change the underlying engine that supports regular expressions as that is built in to the Browser runtime, but i can at least make notation friendlier.
Unified languages in the past like VB6 and Borland Delphi were beloved, and many people were productive in those environments, and clinged to them long after MS for example wanted to migrate people into .NET, because they were so much simpler.
The current complexity level that people have to endure is unnecessarily high. Never before in history did people write in 3 different languages in the same source code file (as they routinely do in JS + CSS + HTML), where they don't even agree on how comments are notated.
The current situation benefits the large incumbents like Google, Facebook and Amazon.
> The current complexity level that people have to endure is unnecessarily high. Never before in history did people write in 3 different languages in the same source code file (as they routinely do in JS + CSS + HTML), where they don't even agree on how comments are notated.
People dont usually put them all in the same file. Html and css are mostly not even programming languages. And shell scripts commonly have sed or awk embedded in them.
I'm not saying that a more unified approach is bad, on the contrary there's pros and cons, but you're being a bit hyperbolic about it. Nothing about the current situation is that new or unique. Nor is proposing a more consistent environment new either. Computer world has been going back and forwards on this since forever.
Okay, i didn't know you had to put in spaces in HN comments to get it to format, here is the regular expression in classic Unix style versus Beads style for the IPv4 address (1.2.3.4):
As you can see the Beads pattern notation allow subroutines, uses keywords like 'digit' instead of \d, and is far more readable. There are plenty of examples, and the more complex the expression the more favorable the comparison.
Not to mention not researching your problem space seems to be an afterthought for these types of people. It's not a novel problem or solution.
Haxe already exists [1] to unify everything, similar to beads' claims. It doesn't.
Unifying has been done better before with it, C (it does run almost everywhere!), Java, Flash/Flex, and JS+HTML. Many have entered. Few win for a little while, and eventually everything loses.
I consider the unified languages of the past to be VB6 and Borland Delphi as two successful environments that had many happy users who preferred to live inside that world and get things done without a lot of fuss. I know my friends when VB6 started to be disfavored by MS and they felt pressure to learn .NET refused to use .NET as it was just too hard compared to VB6. The reference manuals for .NET are 1000's of pages when you print them all out.
My measurement of complexity includes both the syntax of the language, and also how many library API's you have to learn.
Haxe, which has roots in an open source version of Adobe's ActionScript is an excellent product. I often consider switching to Haxe for the implementation of the transpiler as it would yield Linux support. I currently emit AS3 or JS code, but Haxe is a very strong possible direction in the future as Haxe has a lot of portability.
I don't consider C a unified language. It had no database, no drawing model, no event model, and Berkeley Sockets was a library added in to support the internet, that unfortunately did not achieve complete standardization. C is the most portable language, but it just a step above Assembler, and full of pitfalls.
Tools do wax and wane in popularity; they are all useful in certain circumstances, and the more generally useful the tool, the more it gets used. VB6 was abandoned by its owner MS, when Gates retired (Basic was his pet project, as it was the original foundation product of MS' fortune). People used it as long as they could (and some still do). VB6 didn't make the jump to the Internet, but it could have if MS hadn't tried to force everyone into .NET (which was very complex).
comparisons with vb6 and delphi add a lot more context to the philosophy and design of the language. i would consider making that point prominently on the home page.
I don't have time to watch the video right now, but after skimming the language reference I get the impression that is is sort of a modern-ish take on the 4GLs from 80s/90s - not the sexiest thing but I feel like there's definitely room for something like this. Of course, the painful lesson of 4GLs was the consequences of vendor lock-in... I didn't see any links here to the sources.
I like it, but also recoil at the thought of using it. And I think that's a "professional programmer's instinct" talking, saying that I shouldn't settle for this one large dependency that boasts about being the future and has made room for so many little batteries-included features, I should be a big boy and use the most powerful library for every task...in JavaScript, a language that was, mind, designed in a few days and now has an ecosystem built on untrusted third-parties all depending on each other - a state of affairs that has already been demonstrated to fail.
If I were primarily an Excel user, then maybe it would work for me. Working with figures, converting between common units, generating reports and forms, and doing it in a form that acknowledges programming other than "ALGOL derivative"...There is a known niche. Maybe the author knows the niche better than I. There are good ideas here, ideas I want to steal. That is enough to recommend giving it a further look.
I have the exact same reaction. You never want to shit on somebody's ambition, after all they might be a revolutionary, but at the same time the whole batteries-included thing is just setup to fail.
You have an embedded graph database? Why? This is just a symptom of developers general disrespect for the depth and complexity of databases. There's a reason we have so many different different databases, those differences are important and choosing the correct database can make whole reams of code you have to write disappear though the correct database's functionality. Not to mention despite the great expansion of NoSQL databases, the relational data model and associated algebra is one of the most powerful reusable abstractions for organizing information ever invented. Graph databases can do some awesome tricks but are ultimately reproducing the ad-hoc semantics of object graphs.
Same goes for anything that says "deploy over web and native at the same time!" That network hop between you and the browser is real. Every technology that has tried to shove HTTP down into the bowels of the system and pretend that you're writing local, non-networked apps has crashed and burned.
Lastly, I don't want my code to be robust. Fail-fast is good, fail at compile time is best. Robustness like this is nice for people who just want a one-off script to solve a problem but terrible for long-term maintenance of software. Large-scale anarchic systems like the internet require that level of robustness, but that's not how I want to write all of my software, I much prefer stronger contracts between components.
> You have an embedded graph database? Why? This is just a symptom of developers general disrespect for the depth and complexity of databases.
I disagree. This is a recognition of the fact that the line between database, programming language, and operating system is very blurry. It's not that the programming language has a graph database tacked on, it's that the language is a database and leverages that fact to provide features impossible or hard to come by in more conventional languages (e.g. transactional updates, time travel debugging, what-if scenarios, etc.). Still, nothing would prevent you from using whatever database you want in the usual way.
If you use an external database you are not going to get time travel debugging, nor will you have a perfectly uniform internal representation of values. Beads has a primitive type of physical units of measure, so you can store 3 Newtons which internally will be stored as the magnitude 3 plus an array of fundamental units with their exponents. This datatype is not found in MySQL, so external databases work okay as long as you aren't trying to time travel, and either limit yourself to very traditional COBOL era datatypes, or convert everything into string form like JSON has to do.
Beads also has addresses that can be written to the hard drive, because addresses in Beads are not pointers to RAM. How can you store a traditional C pointer into a MySQL database? You can't, you have use a key. which creates baggage.
The virtues of having a simple database inside the language, and a layout/drawing/event model are myriad, and I invite you folks to take it for a spin.
Some of the batteries-included integrated environments like VB6 and Borland Delphi are beloved by their users. Simplicity is wonderful, and i have tried so hard to make Beads simplify the very difficult task of making graphical interactive software.
I think I mentioned the time travelling debugger part of beads earlier. Having built a time travelling debugger a few years ago in clojurescript I immediately understood that this would be the killer feature of beads (for me at least). I do also realise that a lot of the comments here are attacking the author of beads or the initial presentation based on the website. This means that people either like a good flame war or that they need to dig further into the product, which is quite solid. Anyway fixing the home page of beads and the messaging of beads is probably one of easier things to fix , compared with making beads itself
The websites main video is a weird tangent about phones and desktops now both being 64bit. I don't think time travel debugging was even alluded to on the main page.
Developers do not have time to dig through every project's poor marketing in hopes of finding the motivation. The burden is on the project to sell developers, either quickly through explaining their killer features, or for more complicated projects by actually building something with their tools.
I take exception to that inflammatory comment. You have never met me, so how could you possibly know what I do and do not respect? The integration of the database is so i can deliver time travel debugging properly, which i believe will be a mainstream feature within 5 years in almost every language, as the productivity improvement is just too great to ignore.
Please refrain from personal attacks, and take Beads for a spin, and let the work speak for itself.
It has very few errors at this point, is quite usable, compiles very quickly, and makes a great web app that stretches like rubber. There are a few products like Beads, such as Elm, and Yazz Pilot (now called visual javascript). but they are all sufficiently different to be an interesting avenue of study.
Not even looking at the way the language and tool chain works, the home page is very confusing, with each following paragraph making almost no connection to others. What's worse, the YouTube video makes is mostly based on a fairly convoluted argumentation that doesn't seem to be logical to me.
If the page is supposed to draw attention of any fairly technical folks, it definitely needs some more thorough reasoning and argumentation to do so.
I apologize for the bad writing. I am not a good writer at all, but my programming is quite solid, and i hope you will take it for a spin. It has many nice simplifications, from the reformed Regular Expression syntax, to the automatic dependency checking in layout and refresh (if the model changes values, any part of the visualization that is affected is automatically refreshed).
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.
This is kind of a cool project, and I have no doubt it is a good language for the type of programming the author surely does.
However, the design of the language feels like it's a imperative language with a few a few additional features (declarative solver) bolted on to facilitate sub-problems within its use case: well within the paradigm, but lacking real coherent design, or an innovation that would merit non-trivial adoption.
That said, I would be interested at pursuing the source code: it's an interesting hobby language.
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
A few months ago, I watched some videos by Brett Victor and decided I wanted to develop a visual programming language. That led me to https://futureofcoding.org/ and its slack channel.
There was some cool stuff happening on the server, and the admin was doing his best to elevate things, but that slack channel was also the last stop for some people before they descended into templeOS levels of madness.
Right around the time I was joining, the admin posted in the meta channel that, with a heavy heart, he had finally banned [the developer of beads, I feel weird calling him out by name]. Apparently he had been too argumentative and stubborn for the server to further tolerate.
It left a weird taste in my mouth about the future of coding slack channel. On one hand, you don't want toxic people in your community. On the other hand, the server was clearly a channel of last resort for a lot of people with a lot of crazy ideas. Kicking out one if its more prominent members to toil in solitude felt kind of gross.
Its interesting to see that, a few months after being banned, the beads project seems to be materializing.
I don't think you're fully appreciating the context here... The moderator of that community had been trying over and over, both privately and in public, to get this person to follow community norms for years, but they just would not do so.
To me, who has been in that community for years, it was entirely the correct action to take. Moderation is hard and no fun at all, but it needs to be done, or else a community will descend into madness.
I was kicked out of the future of coding chat group by Ivan Reese, who exercised his cancel culture powers to permanently ban someone for daring to say that Steve Jobs had cojones for ordering hundreds of millions of dollars in parts for his products before they even shipped and knew if people liked them, unlikes the cowards at HP who only bought 10k Idea Pads (which preceded the iPad). It is ridiculous to equate a colorful, and accurate, word "cojones" with a descent into madness. Steve Jobs by most personal accounts had a bad temper, but he was amazing, and I for one miss his great designs and inventions that he brought forth. To me, Steve Jobs is the most exciting inventor of my lifetime, an incredible example of masculine energy focused in a constructive and creative manner.
The community didn't vote on it, Ivan exercised his power, because has a personal dislike for me. I met a few nice people on that discord group, but didn't enjoy being followed around by word police.
I do remember this incident well. I guess each community has to decide how it wants to operate when people in that community feel disrespected and criticised. But I also remember this comment from Steve Jobs: https://greatresultsteambuilding.net/impact-teamwork-steve-j...
I did not love reading the code examples. Call me a lightweight, but I think Swift and Kotlin have a pretty good balance between being verbose enough to read easily, and expressive enough to not need a ton of code. This syntax feels like a step backwards.
The problem with both Swift and Kotlin, is that you must use libraries to draw and handle events, which typically makes it tied to a single OS (Swift only really being used in OSX at present). Kotlin might rely on the very extensive JVM libraries, which are horrendously complicated.
I don't know what you mean by a step backwards. This a batteries-included environment like VB6 and Borland Delphi, but emits to the current web app universe we live in, so it is definitely in the now.
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.
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.
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.
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.
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.
I find it amusing how the top item of the stack "to be replaced" says "Unix", but then further down the page it notes that there is no version for Linux at this time.
I don't get it. The pitch is about... 64bits? I've been writing cross platform 64bit software for years, why would I need a new programming language for that? What a strange thing to lead with.
The home page doesn't do a good job at explaining what its about and why I should care. I then looked at the sample code and I still don't think I get it.
> The next generation of languages is now possible: Declarative languages,
Ok, but declarative languages have existed for a looong time too.
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).
Not really a technical comment but this is the first time I've seen language syntax written down with graphs in documentation. I honestly would've preferred text but it is interesting. What tool did you generate them with?
This seems like a mildly interesting project targeting visual displays type niche (is it something similar to the processing language? E.g. a language for making visualizations of data?)
Afaict its features are:
* a string matching DSL that the author thinks is more readable than regex (but what isn't more readable?)
* a very basic graph db
* a syntax that's more Algol like than c (matter of personal taste i guess)
*a declarative layout engine with strong reactivity support
*combining both the server and client side in one lang.
* support for a time travelling debugger
But its totally overshadowed by the utterly bizarre or dare I say "batshit", marketing material.
Beads follows the State-Action-Model pattern (SAM, see sam.js.org) very closely.
Beads is targeting web apps, mobile and desktop graphical applications.
You didn't mention time travel debugging, even on software running on remote customer machines. That's a neat idea.
I would describe the syntax as a mixture of Python and Modula2, which both contributed major features. But has deductive elements as well, which can be traced back to PROLOG.
There are also physical units of measurement such as 3 Newtons * 4 seconds / 3 meter * 2 ergs / 12 kg. I followed the spec from Van Snyder at JPL, who asked the FORTRAN committee to add it decades ago. Only Frink has a stronger unit system.
There are about 70 new things in Beads all told.
I hope that people take it for a spin. If people aren't willing to try new things, how are we going to move forward? You can learn the entire Beads product from soup to nuts in less time than to get half way through a CSS book. Simplicity is a virtue, and thankfully Beads has zero category theory, with no Functors and Monads or Java method factories, etc.
Reading through Beads author's blog reveals him to be a person with decades of experience. To me it appears that Beads is a well thought out attempt to address the multitude of issues that the author has experienced over the years.
That is exactly the sort of mistake that the support for physical measurements mitigates.
There probably never will be a programming language that pleases all the syntax camps and all the semantics camps. Why not just use macro-assembler? It is the purest language that isn't binary machine code.
But that's exactly it - if the goal of this language is to prevent the type of failures that lead to the mars orbiter issue, then its an obvious failure. There's no possible way an interpreted language only usable on windows or mac would be controlling a mars orbiter - it just doesn't have the features neccesary for that usecase. Mars orbiters don't run Windows (nor should they).
That's ok of course, no language can be all things for all people and its ok to have a niche. But when the primary example justification for the language is a problem that the language couldn't possibly address, it suggests that it is hardly a well thought out language.
Almost none of the criticism here has been about the language itself, it has been about the blatent disconnect between what the language is and what it claims to try and do. Maybe its a good language in and of itself, hard to tell. At a glance it doesn't seem particularly groundbreaking, but it doesn't seem terrible either. However, I stand by it being an abject failure in terms of the stated goals of its marketing material.
There is Elm, and Yazz Pilot (now called visual javascript), and the Red project can generate web stuff as well (but is at the moment fairly focused on Crypto contracts).
The "64bit" video and stack of books replaced by a single component made the impression that this must be satire. I didn't look further because of that.
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.
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.
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.
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.
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.
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.
This reads like a marketing webpage and is not technically coherent. What is the purpose that this langauge is intending to solve?
I used to program in a declarative langauge a few decades ago, Prolog. Heck, even makefiles are declarative. Declarative programming isn't guaranteed to be bug-free in the way the page indicates.
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.
The Multics operating system, which was funded by the DARPA at MIT's Project Mac for 10 years, was superior to Unix from a technical standpoint, and it used segmentation.
Unix has Paging but not segmentation. Segmentation allows you to grow a memory block without having to copy as it grows, something that just plain paging cannot do.
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.
Beads can generate desktop and mobile, however 99% of the users so far are just wanting to make web apps so i spend 99% of the time working on improving the web side and client/server output mode.
I feel like this is an unfair criticism. We all have pdf readers.
Lack of linux support is only a worthy criticism because appearently portability is a primary design goal and this is going to "replace" linux, but in general that's criticizing the tress for lack of seeing the forest.
PDF prints well, and has nice search features, and has a nice zoom feature to accommodate people of different visual acuities, which the web does not always do well. This is the first time i have ever seen anyone prefer the web. Maybe if i put a table of contents in the PDF that would help.
There are some people reporting that the Windows .EXE runs okay under Wine in Linux, but yes it would be nice to support Linux desktop natively.
I share your surprise: are there any major languages with a PDF as their main documentation source? Nothing beats an hypertext at looking for something IMHO.
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).
"Graph databases are considered more powerful and modern than relational databases," ... okay? According to what benchmark and for what workloads? A statement like that is an immediate turnoff because it is dismissive of 30 years of database development.
"In many languages the slightest error in input data can cause a program to seriously malfunction. Beads has special rules of arithmetic and a robust mathematical model, that makes it extremely difficult to have a serious malfunction." I don't see how "special rules of arithmetic and a robust mathematical model" makes it "extremely difficult to have a serious malfunction."
Replacing "Unix, SQL, Rails, Ruby, RSpec, Templates, HTTP, HTML, CSS, DOM, jQuery and Javascript" in one language? How does this replace Unix? HTTP? It's not an operating system or a transport layer.
My goal isn't to crush someones idea, but consider your audience: developers.