Paul Chiusano

Came here to say exactly this. And also to point to this excellent article: https://pchiusano.github.io/2017-01-20/why-not-haskell.html

You see them at the author's blog https://pchiusano.github.io He's posted screenshot's and videos about this project. He has allocated 3 months to this project to see where it goes.

The odd thing is unison started purely as a language. Now there's a platform. I often find the best way to understand complex things is to dig all the way back to when they were being thought up. In this case there's a blog post from 2017 that I still find useful when thinking about Unison: https://pchiusano.github.io/2017-01-20/why-not-haskell.html Key quote: Composability is destroyed at program boundaries, therefore extend these boundaries outward, until all the computational resources of civilization are joined in a single planetary-scale computer (With the open sourcing of the language I doubt it will be one computer anymore, but it's an interesting window into the original idea) Personally I find there's a lot to this. It's interesting that we're really, really good at composing code within a program. I can map, filter, loop and do whatever I want to nested data structures with complete type safety to my heart's content. My editor's autocompleting, docs are showing up on hover, it's easy to test, all's well. But as soon as I want cron involved, and maybe a little state-- this is all wrecked. Also deployment gets more annoying as they talk about a lot. So I think Unison always had to have a platform to support bringing this stuff into the language, even though they built the language first. I'd love to hear some opinions from outside Unison about how they like using this language, tooling and hosting. I'd like to hear this too. Also, it would be great if…

You missed the "logical leap" part. It was a big logical leap—bordering on nonsensical which you pretty much acknowledged in your first response. If, when reading someone's comment, your first instinct is to say to yourself, "How could someone think that's a good idea?" then your second thought should be, "Yeah, how could someone think that? I'll bet they don't." This isn't Twitter; replying to a comment as if, out of the range of possible interpretations, what the author intended was the dumbest one—just because you can plausibly argue that's what their words really meant—is pretty much against the rules. > I would assume it's the reading everyone made Even after what just happened, you're still making assumptions? > We all read in good faith That's disputable. Actual observed behavior on HN lately seems to trend towards the easiest/shortest path to dismissal, or: How can I reaffirm that someone I want to disagree with is dumber than I am?, again à la Twitter. > phrase it in a way that's less ambiguous Okay, I'll bite. How should it have been phrased? By the time you had written the comment prior to your most recent one, I had already posted two other comments that were pretty damn specific, one of them excruciatingly so: <https://news.ycombinator.com/item?id=28524423> <https://news.ycombinator.com/item?id=28518839> What you're demanding is to spend an inordinate amount of effort seemingly to optimize for folks who are some combination of (a) subject to…

Yeah I like the idea of visual programming but it's not gonna replace everyday dev work in my opinion. I would like to see more apps for tablets that introduce visual programming into everyday workflows. If you haven't seen the work of Ink & Switch check out these essays on end user programming [0] and an app for basically working on ideas [1], combine these and you get a fluid interface with an easy way of doing some computation (the visual programming bit) which is something I would love to use. But visual programming gets messy if you attempt to do something complex and I don't know if there is any way around this. This then is where there needs to be programs with strong types that can compose with each other, like the example explained in this post [2]. These concepts are all things which anyone using a computer could use, not something just resticted to people who are already "developers", and I think we have to get into that mindset for this type of software to become more successful. [0] https://www.inkandswitch.com/end-user-programming.html [1] https://www.inkandswitch.com/muse-studio-for-ideas.html [2] https://pchiusano.github.io/2013-09-10/type-systems-and-ux-example.htm…

Cool. :) Not sure how well this came across in the post but I was trying to be careful to say that even though there is a tendency for intelligence to arise (it is really more that evolution tends to accelerate its own rate of adaptation over time, for the reasons I gave in the post, and intelligence is the eventual result), whether that tendency plays out for a particular run of the tape may depend on many things. As an analogy, think of the long term trends of evolution like the force of a river, and the biosphere’s evolution like a pebble in that river. Maybe the pebble will be carried a great distance in the direction of flow, or maybe it will get stuck someplace at the bottom of the river for a million years. In that sense, pointing to the historical record of evolution is misleading and too much detail — IMO you have to distill evolution to some computational essence in order to reason about whether it has any long term trends. Something that I don’t think is well known is how likely it is that evolution will get stuck or reach equilibrium (how often will the pebble get stuck), but I think it’s wrong to say there is no long term tendency. Also see this other post which talks more about this, see the Getting Stuck section - https://pchiusano.github.io/2018-04-14/intelligence.html

> “It’s too hard to learn” (If your pet technology were 1000x more productive than, say, Java, would this learning curve really be a substantive barrier? I think the simple answer is "yes". It doesn't matter how much more "productive" something is if the vast majority of people simply aren't capable of learning it (or learning to use it well enough or doing it in a reasonable amount of time or whatever). He does go on to point out: > Though this question is more complicated than you think And suggests one read his more detailed treatment of the question, including what I found most relevant, which is a more nuanced treatment of the notion of productivity, having to do with labor costs, fungibility of that labor, market competition, and overall limited resources. https://pchiusano.github.io/2016-02-25/tech-adoption.html https://news.ycombinator.com/item?id=17114935 I would expect that any technology that can be classified as sufficiently exotic is viewed as a huge risk, one not worth taking, by larger companies, which has traditionally included obsolescent tech and bleeding-edge/unproven tech, but easily includes a language that's too hard for the average programmer learn.

Here is a quick shortlist of some type inference issues (some bugs, some enhancements, and some fundamental limitations of the language design) that I run into pretty much daily: 1. (Search for "asInstanceOf"): http://typelevel.org/cats/tut/freemonad.html 2. (Finally fixed and will hopefully be released soon - yay!): https://issues.scala-lang.org/browse/SI-2712 3. https://twitter.com/extempore2/status/430456002392391681 4. http://pchiusano.blogspot.com/2011/05/making-most-of-scalas-extremely-… 5. (Anecdotal): Various pattern matching peculiarities. Compiler bugs: As long as I write code on the happy path and steer clear of scalaz/shapeless/cats, the compiler is pretty well-behaved and I can go months without getting a compiler crash. However, when I add those in and start writing pure functional code with complicated types that hits the intersections of various features (e.g., GADTs, package objects, implicits), I get a few crashes per week related to known bugs. It works pretty well, and I am not trying to complain too much about all the mileage I get out of Scala and the excellent tooling! Just trying to get the most out of it.

You might be interest to read this article: "The Internet has made defensive writers of us all". https://pchiusano.github.io/2014-10-11/defensive-writing.html >> Writers use hedges in the vain hope that it will get them off the hook, or at least allow them to plead guilty to a lesser charge, should a critic ever try to prove them wrong. A classic writer, in contrast, counts on the common sense and ordinary charity of his readers, just as in everyday conversation we know when a speaker means in general or all else being equal. If someone tells you that Liz wants to move out of Seattle because it’s a rainy city, you don’t interpret him as claiming that it rains there 24 hours a day, seven days a week, just because he didn’t qualify his statement with relatively rainy or somewhat rainy. Any adversary who is intellectually unscrupulous enough to give the least charitable reading to an unhedged statement will find an opening to attack the writer in a thicket of hedged ones anyway. > I love this notion of relying on “the common sense and ordinary charity of readers”. What a wonderful, inspiring idea. I realize I’ve begun writing defensively on the web, putting in hedges and clarifications that really aren’t necessary for a charitable reader. I’ve also taken to toning down any rhetorical flourishes that could be interpreted uncharitably in a way that annoys some people. The result: boring writing stripped of a lot of my own personal style.

Facebook, Twitter, reddit, the Internet itself, the iPhone, and on and on and on—most people dismissed these things as incremental or trivial when they first came out. I would say Twitter and Facebook in particular are still are incremental and trivial as billion dollar companies and always will be. The web is a dumbed down version of older hypertext systems and hasn't shaken that legacy in 25 years. The real problem with the pace of innovation is these things weren't trivial to build, that's why the best we can do is incrementalism. And that comes from the foundation systems we use. When something near the bottom of a technology stack/pyramid offloads complexity to the top, it becomes a nightmare to get anything done. For example, we don't have a natural language command line for regular/stupid users. Instead we have point and grunt GUIs. That means apps have to be monolithic. Apps can't work seamlessly with one another even if the underlying tech allows it. And from that small bit of complexity we get billion dollar walled gardens. More detailed read http://pchiusano.github.io/2013-05-22/future-of-software.html Instead of a simple standard interface for users to access various services we have http://static3.businessinsider.com/image/4dd4d1cf4bd7c8c90f000000-1200… which kills discoverability and creates a constant drag on people to learn a million UIs. And then we hope to fix all that with another layer of AI…

>simple algorithm Reminds me of this article about the deceptive simplicity of evolution: http://pchiusano.github.io/2018-04-21/evolutionary-methods.html Not saying all of that is true. It seems to be pretty much philosohpy at this point. But maybe one day our methods scale up enough or evolve :-) in some other way and there will be a breaktrough in evolutionary AI, like there was in neural nets.

For a modern take on this you might like Paul Chiusiano’s work http://pchiusano.blogspot.com/2013/05/the-future-of-software-end-of-ap… And that culminated in https://www.unisonweb.org/ Essentially all code is pure functional and content addressable, meaning it’s inherently distributable and transferable (including closures). Like Smalltalk but with more use of modern programming language theory.

Please read https://pchiusano.github.io/2014-10-11/defensive-writing.html

The Unison language stores code as a syntax tree and they're planning to support multiple alternative syntaxes for the language. https://www.unisonweb.org Unison’s core idea is that code is immutable and identified by its content. This lets us reimagine many aspects of how a programming language works. We simplify codebase management — Unison has no builds, no dependency conflicts, and renaming things is trivial. Some blog posts by the author of the language describing a bit of background https://pchiusano.github.io/2013-05-22/future-of-software.html https://pchiusano.github.io/2013-09-10/type-systems-and-ux-example.htm…

https://pchiusano.github.io/2017-01-20/why-not-haskell.html I found this argument compelling: Haskell is good for programs like compilers: they do many interesting things but without needing to interact with the outside world as much. Whereas "straight-forward CRUD app" is more about interacting with the outside world, which is harder to do in Haskell compared to, say, Go. HN discussions 2018 https://news.ycombinator.com/item?id=17114308 2017 https://news.ycombinator.com/item?id=13450828

Somewhat related: https://en.wikipedia.org/wiki/Worse_is_better https://pchiusano.github.io/2014-10-13/worseisworse.html https://news.ycombinator.com/item?id=15125949

That has exactly been my experience as well, and the reason why I decided to work with Haskell professionally instead of continuing to write Python, Elixir or what have you. On to the topic of this submission itself, Elm turned out to be a gateway drug to Haskell for me. Similar to Paul Chiusano[1] I decided to switch from Elm to GHCJS (Haskell). I started with https://haskell-miso.org/ (based on the Elm architecture) but I'm currently developing using http://docs.reflex-frp.org/ [1] https://pchiusano.github.io/2015-04-23/unison-update7.html

No, the responses to the comment are a common fallacy on display, where rather than addressing the point of the thought experiment, which is clear enough, people attack the premise. There is no amount of defensive writing[1] that can bring relief to this situation. 1. https://pchiusano.github.io/2014-10-11/defensive-writing.html

I apologize that Vonnegut wrote his letter at a time before the internet made defensive writers of us all. https://pchiusano.github.io/2014-10-11/defensive-writing.html

From the about section: "Unison is a new programming platform that rethinks just about every aspect of the programming experience." Haskell + Semantic editing + Collaborative editing + Distributed ... Organised links about the project by the author: http://pchiusano.github.io/unison/

Next time, just link: https://pchiusano.github.io/2014-10-11/defensive-writing.html

This seems like a good example of this article posted yesterday: https://pchiusano.github.io/2014-10-11/defensive-writing.html

Here's the most recent video that I could find: http://pchiusano.github.io/2015-03-17/unison-update5.html A few of the other posts have videos too: http://pchiusano.github.io/unison/

If this video < http://pchiusano.github.io/2015-03-17/unison-update5.html > is an example of this, then yes, it does look annoying and inefficient. Now I'm not sure if I understand exactly what he's doing here, but it looks like something along those lines: rather than inputting what he wants directly via the keyboard, he has to choose a pattern (like variable-operator-variable) from a drop-down list, and then tab between the fields to fill in the pattern. A poor analogy might be the difference between speaking words verbally to form a sentence vs. shuffling through a stack of index cards to find the right words to arrange on a table to form a sentence. The latter would be useful if you were just learning a language, but once you know how to speak it, that would be an enormous waste of time.

Here are some more blog posts about the project: http://pchiusano.github.io/unison/ As far as I can tell, the goal is to put interaction with a UI on the same level as editing a program. To this end, Unison expressions, values and UI elements all live in a single syntax tree which can be edited in a structured way. A demo would go a long way toward making this all clearer. Even some text describing what it would be like to use the finished product would help.

Awesome project. Ignore the haters. I think this (https://pchiusano.github.io/2015-04-23/unison-update7.html#refactoring… was the link that I found most helpful to get an idea of what you're doing, of the random set of pages that I flipped through.

I dislike it when people say languages are either 'practical' or 'well designed'. As if a language is only useful if it's not built on sound mathematical ideas ... Generics are not a particularly new idea and nobody who uses language that implement them yearn for the days when they weren't around. See Paul's post on the idea that 'worse is better': http://pchiusano.github.io/2014-10-13/worseisworse.html

http://michaelochurch.wordpress.com http://thearchdruidreport.blogspot.com/ http://pchiusano.github.io/ (was http://pchiusano.blogspot.com/) http://www.daedtech.com/blog http://yosefk.com/blog/ http://oldurbanist.blogspot.com/

CSS is fundamentally broken -- it lacks a property which is pretty basic to all systems, namely abstraction. I think Paul Chiusano put it way better than I could: http://pchiusano.github.io/2014-07-02/css-is-unnecessary.html