One thing that takes away from programming languages is not having code samples on the index. I think this lets someone know immediately if it's interesting to them or not. Show a sample of code with the console output or a screenshot of an UI from the code. I think Racket had it right ages back. They would show everything from a web server, to other things. This is what major programming languages (with some exceptions) basically do and it gives a developer more information than any amount of marketing speak.<p>That said, I had to dig in the documentation to find code, and it didn't seem as obvious cause the syntax is definitely different from what I'm used to and there's weak syntax highlighting.
Reading the tour[1], I got the impression of being struck by something not that surprising, but still fundamentally groundbreaking.<p>Beyond just the idea of a global program store (which I hope has space for some virtualenv equivalent), the cleverness of effect handlers as a first-class language feature is very exciting.<p>Once the type system is more mature, this could easily be the next kind of Haskell - a language which redefines modern ideas of good programming.<p>1: <a href="https://www.unisonweb.org/docs/tour" rel="nofollow">https://www.unisonweb.org/docs/tour</a>
Kudos to them for not using the buzzword, but if you believe in the notion that 'blockchain is just a fancy buzzword that gives developers the ability to get managers to agree to larger budgets to clean up tech debt', this is.. blockchain programming.<p>One problem I did find: Somewhat deeper into the tour, the tour makes the claim:<p>> a Unison codebase can be versioned and synchronized with Git or any similar tool and will never generate a conflict in those tools.<p>This is pratically speaking of course not true: If you have some unison codebase, whilst under the hood it's all hashes, that doesn't change the simple fact that if 2 people both check out the exact same code, and then both people make a change to how the software operates, where that change is conflicting (say, I make the green 'OK' button now red, and you make it blue), you.. have a conflict. That is a fundamental property of this interaction; no language bells and whistles can ever change this fact.<p>So, what does happen in unison? Is it 'last committer' wins? That'd be a bit problematic. A conflict in your version control system, _IF_ it is representative of the fact that there was an actual conflict (as above with the button and the conflicting colours), is a good thing, not a bad thing.
I find the content-addressed, name-independent, immutable (kind of blockchainy) approach to source code very interesting. On the other hand this seems to be rather orthogonal to other (semantic) aspects of the language.<p>I wonder what would happen if we would change one thing at a time to test the idea: create something like unison based on an existing popular programming language. (python, javascript, java, etc...) All the syntax handling, building and version control would be done the unison way, but the interpreter would be the same as today in that popular language. The benefit would be that a lot of existing code could be transferred into the initial 'blockchain', with all the current dependency hell being solved from day one.
I did not think this through deeply though... Maybe some aspects of existing languages prevent them to be handled the 'unison way'?
"Unison: a new distributed programming language" by Paul Chiusano [1]<p>1: <a href="https://www.youtube.com/watch?v=gCWtkvDQ2ZI" rel="nofollow">https://www.youtube.com/watch?v=gCWtkvDQ2ZI</a>
Algebraic effect handlers no doubt seem to be the future of getting side-effects under control in programming languages, much like in the way of what immutability has done for data.<p>My (admittedly little) experience with Unison though is that it's far from ready for the spotlight however. Much of the docs 404, and joining their discord mostly resulted in the advice to wait for future releases.<p>I wish Microsoft would invest in something like the koka language <a href="https://github.com/koka-lang/koka" rel="nofollow">https://github.com/koka-lang/koka</a>. Perhaps the idea of content-addressable / immutable code could find a place too, but I think it's less critical.
I have learned a lot from the creators Paul and Runar in that past. Their book on FP is legendary in some circles. Unison seems like a super ambitious undertaking, but I wouldn't bet against this team.
I recently came across Unison through YouTube recommending me a series of videos from the "Strange Loop" channel [1]. The fundamental idea of uniquely addressing functions based on a hash of their AST is mind-blowing to me. Immediately my mind started to consider many of the possible paths such an idea could lead down, many of which are clearly tickling the minds of many of the commenters in this thread.<p>My first thought was the same insight from von Neumann architectures: code is data. So I thought of package repositories with URLs corresponding to hashes of function definitions. <a href="http://unison.repo/b89eaac7e61417341b710b727768294d0e6a277b" rel="nofollow">http://unison.repo/b89eaac7e61417341b710b727768294d0e6a277b</a> could represent a specific function. A process/server could spin up completely dumb other than bootstrapped with the language and an ability to download necessary functions. You could seed it with a hash url pointer to the root algorithm to employ and a hash url to the data to run against and it could download all of it's dependencies then run. I imagine once such a repo was up and running you could do something like a co-routine like call and that entire process just happens in the background either on a separate thread or even scheduled to an entirely different machine in a cluster. You could then memoize that process such that the result of running repo-hash-url against data-hash-url is cached.<p>e.g. I have <a href="http://unison.myorg.com/func/b89eaac" rel="nofollow">http://unison.myorg.com/func/b89eaac</a> run against <a href="http://unison.myorg.com/data/c89889" rel="nofollow">http://unison.myorg.com/data/c89889</a> and store the result at <a href="http://unison.myorg.com/cache/b89eaac/c89889" rel="nofollow">http://unison.myorg.com/cache/b89eaac/c89889</a><p>1.<a href="https://www.youtube.com/watch?v=gCWtkvDQ2ZI" rel="nofollow">https://www.youtube.com/watch?v=gCWtkvDQ2ZI</a>
This is cool.<p>I've wanted to see a Merkle tree based AST for faster incremental compilation (and incremental static analysis).<p>I wonder if the source manager interface makes this easier to use than editing source files?<p>AST can still be the source of truth. To edit need to generate source text from AST, edit as text, parse to AST, save.<p>In other words, I think most of the benefits of this can live behind the scenes for other languages.
"As a result, a Unison codebase can be versioned and synchronized with Git or any similar tool and will never generate a conflict in those tools"<p>Conflicts are a feature, not a bug. If two developers are making divergent changes in the same piece of code, I suppose Unison would just let the divergence happen, essentially forking the code. I don't think forking code is the right default.
I like the idea of syntax-tree rather than filesystem directories (if that's the main difference).<p>Seems like this could be implemented in other languages though, and don't really understand why we need yet another new language.<p>For instance, can I not build my JavaScript code in similar ways: I would need a compiler that stores things in trees rather than dirs.
No mention of Smalltalk in the comments? The "codebase" that is managed by ucm sounds very similar to Smalltalk images. I am personally delighted about this.
Very cool. Glad to see someone tackling the idea I first saw brought up by Joe Armstrong[0]. When I read his post it made so much sense, I was hoping I'd get to see someone try it.<p>[0] <a href="https://joearms.github.io/published/2015-03-12-The_web_of_names.html" rel="nofollow">https://joearms.github.io/published/2015-03-12-The_web_of_na...</a>
Content-addressed, immutable code? Reminds me of <a href="https://thedailywtf.com/articles/the-inner-json-effect" rel="nofollow">https://thedailywtf.com/articles/the-inner-json-effect</a>
At first, this sounds like a great idea. On second thought, I have two major categories of concerns:<p>1) If I fix a bug in a function, (thus creating a new version of an existing function) how do I propagate that fix to all that code that transitively depends on the buggy version? Doesn't that mean I need to create new versions of all the downstream dependencies? Doesn't that defeat separate compilation? Does this scale?<p>2) Does this closely couple interface and implementation? Is it a hash of an implementation, or a hash of an interface? Is it possible to depend only on an interface, and not on an implementation?
Hell yea, we can finally move forward with editors now. No more saving files with syntax errors. I imagine you could move a lot of paredit functionality into an editor like this, or have excellent voice editing.
> A friendly programming language from the future.<p>I loathe marketing BS like this. No, you’re not from the future, you pretentious twats.<p>If you have a good idea, let it stand on its own merit, don’t dress it up with manipulative language.
A TLDR for the tour[0] based on my understanding (please fix me if I’m wrong):<p>Unison is a functional language that treats a codebase as an content addressable database[1] where every ‘content’ is an definition. In Unison, the ‘codebase’ is a somewhat abstract concept (unlike other languages where a codebase is a set of files) where you can inject definitions, somewhat similar to a Lisp image.<p>One can think of a program as a graph where every node is a definition and a definition’s content can refer to other definitions. Unison content-addresses each node and aliases the address to a human-readable name.<p>This means you can replace a name with another definition, and since Unison knows the node a human-readable name is aliased to, you can exactly find every name’s use and replace them to another node. In practice I think this means very easy refactoring unlike today’s programming languages where it’s hard to find every use of an identifier.<p>I’m not sure how this can benefit in practical ways, but the concept itself is pretty interesting to see. I would like to see a better way to share a Unison codebase though, as it currently is only shareable in a format that resembles a .git folder (as git also is another CAS).<p>[0]: <a href="https://www.unisonweb.org/docs/tour" rel="nofollow">https://www.unisonweb.org/docs/tour</a><p>[1]: <a href="https://en.wikipedia.org/wiki/Content-addressable_storage" rel="nofollow">https://en.wikipedia.org/wiki/Content-addressable_storage</a><p>[2]: <a href="https://github.com/unisonweb/quickstart" rel="nofollow">https://github.com/unisonweb/quickstart</a><p>PS: The website is very well made, but I would like to comment that there should be two buttons on the top front page, the tour and installation, as I think most people want to have a glimpse of the PL before installing.
I, at least was puzzled because I thought the button was a link to an introduction of the language.
Wondering if Unison was designed as (or ever planned to become) a general-purpose language or it something more domain-specific, e.g. distributed computations.
This is seriously impressive. I've always felt that some kind of database system is needed for code in which you store each function individually. Unison not only has that, it goes one step further to identify a function by its hash. I can't wait to see what the world of programming can become along this direction.
Append only is nice, but I would think a "Garbage Collect" would be useful. Remove all the code not attached to the import tree anymore. Otherwise you will just keep collecting junk forever Honestly git has the problem too, but I expect orphaned/dead code will happen a lot more with this approach.
Was thinking of writing this years Advent of Code in Unison but changed my mind because of its very young age and switched to Zig instead. But I'll very much consider it for next year. I really think some of its ideas are, if anything else super cool and worth learning and thinking about.
Maybe I'm missing something, but this seems like it would get unwieldy very quickly for anything more serious than toy examples.<p>Even the toy examples I'm having trouble following along with.<p>The benefit of code-as-text is that you can navigate the text without knowing what you are looking for.<p>This seems to take the opposite approach of making it very easy to look things up <i>assuming you know ahead of time what you are looking for</i>.<p>That is something that a good usage of grep or some more sophisticated IDE integration will already take care of for you.<p>The only thing I could see this being potentially useful for is "notebook" style computation, where you are really only using the language to do things like structured math calculations.<p>What am I missing here?
For a good introduction, watch this talk at 1.5x speed from 2:50 to 5:40<p><a href="https://youtu.be/gCWtkvDQ2ZI?t=170" rel="nofollow">https://youtu.be/gCWtkvDQ2ZI?t=170</a>
Related from 2015: <a href="https://news.ycombinator.com/item?id=9708405" rel="nofollow">https://news.ycombinator.com/item?id=9708405</a><p>A larger thread, also from then: <a href="https://news.ycombinator.com/item?id=9512955" rel="nofollow">https://news.ycombinator.com/item?id=9512955</a>
Is the Unison codebase manager written in Unison?<p>What other user-facing open-source softwares have been written in Unison?<p>Which of those softwares has been used for months or years by at least one person?
Maybe I've been out of the game or something. But I don't think saying everything is "content-addressed" can land as such of a big mic-drop moment when I've never heard the term or the concept in my life and the front page does absolutely nothing to explain it beyond that.<p>------
EDIT: My tone here is a little more antagonistic that I meant (proofread kids, don't just check for spelling and publish) but my first impression was a kind of "buzzword-y" vibe. I've looked a bit more and the authors seem genuinely passionate about shaking things up and trying something completely different, which I can respect. I'll leave it up as is because I still think my issue are legitimate, but the tone is a little off and I apologize.
------<p>Let's take my discovery path so far as an example:<p>> Functional language: cool cool. I know what that is. Immutable: also cool. Content-addressable: no clue. Saying it'll simplify code bases and eliminate dependency and "no builds" is supposed to sound amazing, but it really doesn't land when I have no clue what the premise is.<p>> Alright, that's it for the front page. No code examples, nothing linking the currently known to this new paradigm-shifting stuff. K. Let's try the docs.<p>> The Welcome is the state of the project without saying anything about the language itself. Roadmap isn't gonna help Quickstart! Let's look there.<p>This amount of effort for discovery isn't very helpful for me. I found a selection of talks elsewhere on the site. One of them is labeled "This is a longer (40 min) introduction to the core ideas of Unison and probably the best talk to start with." That might be a nice link for the front page.<p>I unfortunately don't have anymore time to look at this this morning, but the first 5 or so minutes of the talk say waaaaaaaaay more than the first however long I spent. Honestly, I think all of that information (code examples, linking core ideas to what we already know, basis of comparison) could be on the front page.<p>The tl:dr I can glean from it is:<p>It's kinda like Haskell, but every definition is turned into AST and put in a hash table. Any references are secretly references to the table, so changing a definition is making a new hash and changing the reference, and renaming is changing the reference to name table.<p>Also, everything is append instead of rewrite, which makes all kinds of stuff cleaner, like versioning and refactoring.<p>Pretty neat idea, I just don't really like how long it took me to come to that knowledge. I don't know how well it would scale or be usable in a real world scenario, but I also have never used Haskell or any functional language in a "real world" scenario so I'm not the best one to ask.
>>code is content-addressed and immutable.<p>No, as I keep insistently repeating: Code is content-immutable and addressed.<p>Also, Urbit is a lie, Surface detail is true and you are a lie and your code is retarted.
The name is already pretty taken....<p><a href="https://en.wikipedia.org/wiki/Unison_(disambiguation)" rel="nofollow">https://en.wikipedia.org/wiki/Unison_(disambiguation)</a>