wdanilo

Hi! Some friends of mine, ex-YC founders were drowning in a flood of emails from investors and clients. To save themselves, they built an internal tool that worked so well, they decided to package it into an app (I was helping them a little bit).

There is a bunch of tools that allow you to create summaries, help writing replies, etc, but Blinkfeed builds the UI/UX around these concepts, delivering something way more refined than anything I've seen. What do you think about it?

Congratulations, Arnaud! I really like the idea of your tool. I was using many tools to track dev productivity in the past – with all kind of charts and plots. Somehow, I never got answer to the question "what do we really spend time on? Is this mostly bug fixing, delivering new features, and how does it affect our KPIs?". I like that Echoes focuses exactly on that.

I've got one question – would it be possible in the future to generate some kind of alerts for the managers when for example the technological debt is growing above some threshold?

Thank you for the nice words, we do our best! <3

Regarding collaboration, absolutely! Unicorns are born only from group effort :) Join our Discord at https://discord.gg/enso and let's have a chat!

That's right, we will be able to cut it down in the future. Let me explain why:

1. Enso compiler bases on GraalVM which is 400Mb (packed)[1].

2. The package contains GraalVM implementations of Python[2], R[3], and JavaScript[4] compilers, which weight 150Mb, 70Mb, and 50Mb respectivelly.

3. The package contains OpenCV library, as Enso has built-in bindings for it, which is 200Mb.

4. The rest (approx 200Mb) are core Enso libraries and tooling.

We will be able to cut it down in the future as soon as we release Enso Marketplace which would allow you to install these things on-demand.

[1] https://github.com/graalvm/graalvm-ce-builds/releases/tag/vm...

[2] https://github.com/oracle/graalpython

[3] https://github.com/oracle/fastr/releases/tag/vm-21.1.0

[4] https://github.com/oracle/graaljs

Btw, I think it's a good time to also announce that we have just started an "Enso Partnership Program" – long story short, if you have an idea of what you want to build on top of Enso, we'd like to help you deliver it! <3 Just tell us what you want to build by filling up this form (https://airtable.com/shrsnx2mJuRn0MxIS) and we will provide you with:

1. Dedicated Enso Expert. We will assign you with a dedicated Enso Expert from our side who will be responsible to help you build your use case and guide you step by step in case you have any problems.

2. Priority Bug Fixing. Enso is currently in alpha stage, so it contains bugs and is rough around the edges. We are working really hard on improving it, but bugs will occur. In case any bug will prevent you from progressing, we will focus on resolving it ASAP. It would normally mean, that you should expect fixing it in hours / days after reporting it!

3. Project Delivery Guidance. We want to guide you how to get your project on track and how to progress trough all of its stages, from the initial planning, trough prototyping, till releasing the working version. Based on our experience, it is best if you will have design / progress calls with the assigned Enso Expert once a week. Normally, 30 minutes call should be more than enough to be sure that everything goes according to the plan.

4. Extended Support. We know how important it is to get help when you are building things. We will try to reply to your questions in max 1 hour after you ask them. Of course, we are not able to cover all timezones right now, but we will do our best, especially in the range of 8 am - midnight CET.

5. Enso stuff. We would love to share with you how we appreciate that you are building things on Enso. We would love to send you some cool Enso stuff (like t-shirts, stickers, hoodies).

We're looking forward to your feedback! <3

Thank you for the list! Answering shortly:

> On the signup screen I accidentally clicked 'sign in with google' then reailzed I didn't want to, and I don't think there's a way to go back to the first screen (without restarting the app)

Noted! Will be fixed :)

> When I go to Help -> Documentation in the mac native menu bar I get a link to electronjs documentation, not Enso docs

Oh, I was not aware that it is there! We will remove it. Thanks for catching it! :)

> The button in the top right that looks like a power button was a bit confusing. I didn't understand what it did immediately and there's no tooltip to explain it.

One of the things that we are improving now is adding hover-labels for buttons with explanation of what they do. We also want to make the UX much more approachable by new users. It will take us some time (a few weeks, as it's planned after fixing stability issues), but it's already on our short-term plan to be added!

> I noticed a bug where if I hit the spacebar multiple times quickly to toggle the result view the entire canvas goes blank, then comes back if I hit the spacebar again

I cannot reproduce it. Would you be so nice and create an issue report with a short screen recording and your machine spec here, please? https://github.com/enso-org/enso/issues

> I found it a little confusing that the args of a node are displayed as a var name even when the exact input is known. For example I had the constant `6` as an input to a function `n.up_to` which rendered as `number1.up_to` when I expected to see `6.up_to`.

This is one of the things we are currently working on! This will be much improved in one of the following minor releases (we will do a release every week now).

> I didn't find it intuitive that you cant (I think) edit existing nodes. Do you have to create new ones from scratch, or copy/paste somehow?

You can do it. We use double-clicking to ENTER the collapsed nodes. To edit the node use `CMD + Left Mouse Button` on the expression (or `ctrl` if you are not Windows or Linux). The full list of shortcuts is here: https://github.com/enso-org/ide/blob/develop/docs/product/sh...

We want to add an icon for that as well, so it will be easily discoverable in the future.

I'm really happy that most of these points cover with our dev plans! It means that in a few weeks you'll have a much better experience <3

I believe that functional programming with immutable memory is the only model you can use in order to create a visual language that you can reason about. E.g. you do not want to allow some nodes (visual components) to affect the execution of other nodes if not connected with each other. There are many more such implications there!

Luna was our early prototype and it indeed had significant performance problems. Our new JIT compiler is able to execute the graphs really fast (in fact, in many cases we are up to 80x faster than Python nowadays: https://github.com/enso-org/benchmarks).

However, sometimes we see that the WebGL is super-slow on some machines. May I ask you for more details, please? The important bits would be whether you experience the slowdown when using the IDE (like dragging, zooming) or when waiting for data to be computed? In both cases, we would be more than thankful for an issue containing machine spec: https://github.com/enso-org/enso/issues .

Enso should work for you with the same visual performance as in this video (this was recorded on a few years old MacBook Pro): https://youtu.be/fQvWMoOjmQk . If its not this smooth, we need to investigate it, because this is something system / machine specific.

There is unfortunately no other way for us to improve and progress from alpha to beta, so we will be very thankful for help here! <3

> Certainly. I was struck by it a few years back, around the same time as Luna was in early alpha stage. In fact I found it while doing research for my thesis, based on this vision. I was naive enough to think I had an original idea when I started.

That's quite a story! I don't know what you do now in your life, but sharing the same vision is absolutely crucial for our team and if you are up to talk about collaboration, I'd love to chat with you! If so, ping me at wojciech.danilo@enso.org! <3

> And the only sensible way around these problems is to integrate both. Just this idea addresses most of the relevant criticisms of visual programming languages. A list of these I compiled at the time was [...] You might be about to tackle these pretty well. ;)

100% this! This is what I was trying to express in one of the parts of our blurb text of this post. Most visual languages are ... not really languages. They lack abstraction mechanisms and love. A love that is needed to make a production-ready tool. Textual languages are working really well because we put a great amount of love in developing them. We have seen a lot of visual languages solving domain specific problems much better than textual ones – Sidefx Houdini for example. And we believe that with much more dose of love, we are able to apply visual programming everywhere where people are processing data that can be visualized and where interactivity of the creation process matters :)

> I bet. Especially at the level of integration that you're aiming for. My own humble prototype was as simple as I could come up with and already revealed some major issues that a real-world implementation would have to grapple with.

I believe that anyone who tried implementing something similar would totally understand it! This is also one of the reasons the criticism appears. It is hard to develop a robust programming language. I believe that developing visual one is even harder than textual one, as you have this additional graphical UX element, that is not as heavily researched as the textual layer we all know.

> Would you say performance was one of the tricky bits? What was the most tricky?

A lot, lot of things! Including:

- Performance (obviously).

- The way errors and exceptions should propagate (you want to have exceptions in low-level text API, but they do not make sense in the graphical layer). We have special conversion mechanism that allow you to convert exceptions to dataflow errors now.

- The language mechanisms. Algebraic data types, type-theory. For example, Enso has a notion of Atoms – similar to ADTs constructors, but each one being a separate type. Also, Atoms can be shared between types. What's interesting, Enso type system does not have subtyping. Instead, we think about our types like about set of values. So for example, it is correct to write in Enso `1 : 1 : 1 | 2 : Natural : Number : Any` (read `:` as "left side is contained in the set defined by the right side). We designed a lot of stuff around this custom type system in order to make the language extensible, easy to use, and play nicely with foreign typed and untyped languages.

- Memory management. If you want to have a robust visual environment, non-connected nodes cannot influence each other. So Enso structures are immutable. How to make that efficient was very tricky.

- Currying, good support for recursion was tricky as hell. We always wanted Enso to be both powerful and easy to use. Nodes that do not have all connections plugged in are curried functions – which gives you so much power in a very natural fashion. However, in order to make that JIT well in a dynamicaly typed land, is tricky as hell.

- Proper recursion handling. This requires segmented stacks and a lot of low-level utilities you'd not normally get on JVM / GraalVM.

- Visual layer – in order to create really high performance GUI we settled down on implementing our custom WebGL vector shapes rendering system based on Signed Distance Functions rasterization (https://en.wikipedia.org/wiki/Signed_distance_function). The results are amazing, we are able to render thousands of connected nodes in 3-4ms per frame (of course as tests, no one is creating such big scenes - Enso allows you to collapse nodes together to keep workspaces small and well layouted).

And TBH, many, many more! Looking from a time perspective, that was a good technological journey. I cannot be happier that we successfully did it. We would never ever do it without exceptional team of genius developers we have. Hey Enso team! Thank you for that <3

Thank you! We hope for it as well. We really hope that Enso would eventually become applicable to a much broader space than Alteryx is applicable nowadays. In fact, Enso already provides much more powerful toolset in many cases, like unstructured data processing, true polyglot support, high-performance visualizations, interactivity, true batch-mode, etc. On the other hand, we are aware that there are still bugs and that our onboarding is far from perfect.

Anyway, I would really love to chat more with you about these cases if you'd like too! We are looking forward to work with companies in this space and we are providing them with a very special deals now, including lifetime discounts, dedicated team members building highly tailored libraries, and helping solving data-related problems! If that sounds interesting to you, please write to me a short message at wojciech.danilo@enso.org ! :)

It did come naturally, kind of! This is the one thing we heavily underestimated when starting Enso – the amount of time that is required to make the language's design consistent in both representations. In fact, our desire to create a REAL programming language with strong math background was a two-sided sword. It took us a significant amount of resources, but at the same time, it provided us with a very consistent and a well working solutions.

The same is applied to our data-flow errors. Think of them like about Haskell's `Either` or Rust's `Result` types, but with automatic lifting (automatic applicative functor lifting). So in Enso, you can have a "broken value", like a string read from a file that could be broken because the file did not exist, but you can still concatenate it with other string WITHOUT using any special syntax, and the result may also be broken. In Rust and Haskell you can do the same, but with a special syntax like `(+) <$> str1 <+> str2`.

I hope it clarifies some things under the hood! :)

No, it's not. TBH, we were not aware about it until recently, when someone from our community mentioned this project. It looks not maintained anymore nowadays, but I think it's a good idea to reach out to its authors, tell "hi" and chat about our co-existence! I'll do it :)

Thank you! And of course, everything (but the Cloud management) is Open Source on our end! You can find our custom WebGL rendering engine here (https://github.com/enso-org/ide/tree/develop/src/rust/ensogl), our event FRP handling system here (https://github.com/enso-org/ide/blob/develop/src/rust/lib/fr...) , and other related libraries here (https://github.com/enso-org/ide/tree/develop/src/rust/lib). They have pretty good documentation and a lot of example demo scenes, however, in case you'd struggle with using them, join our chat (https://discord.gg/enso) and we'd love to help you getting started! <3

Hi, thank you for the nice words! We believe in the same vision. Visual languages are amazing for some applications, however, text-based development is superior in many cases, like low-level algorithm development, API connections, compatibility with version control systems (GIT), etc. I am really happy that we were able to overcome all design problems and make these two representations 100% compatible. TBH, when we were starting Enso, we were not aware how many corner cases and tricky technical details we would need to solve in order to bring it to the world!

I would love to chat about the cases you have in your mind! We really want Enso to redefine the data analysis environment and thus, we also want it to be accessible to the wide audience of customers. That's why we have the free Open Source version and we are trying to have a very flexible pricing that suits wide range of companies. I'd love to talk more about it too! If that works for you, please ping me via our chat (https://discord.gg/enso) or via email (wojciech.danilo@enso.org)! :)

Amazing, I'll reach you out! Thank you so much! :)

Thank you :)

You are absolutely right! Luna was our prototype with several issues – slow GUI, low compiler performance, and lack of extensibility. That's why we went into heads-down mode for almost 2 years to make a production version based on customer and user feedback. As a result:

1. Rendering Performance. We have created a custom WebGL-based vector shapes renderer which is really fast (we have tests of rendering over a million of points at 60 FPS on my MacBook): https://github.com/enso-org/ide/tree/develop/src/rust/ensogl

2. Computing Performance. We have rewritten the compiler from scratch. We used the GraalVM / Truffle framework under the hood as our core JIT framework, and we have added tons of custom optimizations on top of it (e.g. to efficiently support immutable memory, currying, etc). As the result, Enso is right now up to 80x faster than Python (benchmarks: https://github.com/enso-org/benchmarks).

3. Extensiblity. The new Enso is a fully polyglot language – it allows you to literally copy-and-paste code in Java, JavaScript, R, and Python (soon also Ruby, Scala, Kotlin, Rust, and C) directly into Enso nodes without the need to write any wrappers and with a close-to-zero performance overhead. You can even create closures in the visual environment and pass them as arguments to functions in e.g. JavaScript, which will call them with objects created in JS, which will be understood by the Enso nodes! See our videos and compiler section here to learn more: https://enso.org/language

Did I answer your questions? :)

--- EDIT ---

Thanks for catching the typo! Fixed :)

Hey, thank you for the detailed list of issues.

1. Some of your points surprised me a lot, including "Scrolling the preview would often pan the entire window", "Panning the window was really sluggish", and "It was really hard to drag lines" – these should not happen. We are heavily testing Enso on macOS and these issues are not known. I know I'm asking for a lot, but would you be so nice and have a 15 mins call with me so I could see how Enso behaves on your end?

2. Some of these points did not surprise me – our text editor is really broken right now and this is one of the things we are improving for the next release. That's why we normally do not even tell people how to open it! However, if you had any issues with editing expressions on nodes (cmd + left mouse button), I'd love to know more about that as well.

Thank you <3

I'm really sorry to hear that you had issues with running it! In case you do not have enough time to report the issue, just make a screenshot and post it on our chat (https://discord.gg/enso). We will then create the issue for you and we will let you know as soon as it will be resolved. We might also ask you for some additional info, but we'll try not to take too much time of yours! It is very important to us to fix all the issues for the upcoming stable release :)

Hi! Good to see a fellow Krakow citizen! :)

Enso is cloud ready! It has two parts – web-based UI + server-side compiler / data crunching engine. The version you are able to download from our website just contains both parts glued in a single application. We will be releasing Enso Cloud (hosted version) soon! However, it is very important for us to have the desktop version as well, so everyone can just use it for free :)

I hope it makes sense to you? :)

Yes, you can! Enso is a purely functional language with currying, immutable memory, algebraic data types, data-flow errors, type inferencer, JIT compiler, and even a special kind of a monadic type system with auto-lifting (although we do not expose the ability to define custom monads to the users yet) :)

You can create closures in multiple ways:

1. The simplest and most visual is by using currying! If you create a node (a visual component) and you do not connect all its required inputs, the output of the node is the curried function (function with partially applied arguments). You can then connect it to other expressions, like `map`.

2. Another way is to use expressions on nodes. You can use the lambda syntax, like `x -> x.noise` to define a lambda. You can also make it shorter by using curried operator sections `(. noise)`, and even shorter by using the Enso's operator precedence as `.noise` and use it for example as `map .noise`.

If you want to learn more about Enso syntax, we have a page describing it here: https://enso.org/docs/syntax . Also, if you go to our language-focused subpage, please check out the video named "Higher order functions". It does not show currying, but it shows the usage of the expressions on the nodes: https://enso.org/language

Did I answer your question? :)

Thank you! That's a good question and yes, there is a small story to it. There were several problems with the old name. A lot of people were confusing "Luna" with "Lua", the name is so popular that absolutely good website names are already taken, and also, "Luna" has no logical connection to what we do.

On the other hand, the name "Enso" is not similar to any of the popular languages names, we have a beautiful https://enso.org domain, and also, in Zen, ensō (円相, "circular form") is a circle that is hand-drawn in one or two uninhibited brushstrokes to express a moment when the mind is free to let the body create (source: Wikipedia). This is exactly what we want Enso to be – a creative canvas with two perfectly connected parts – the textual and visual one :)

Yeah, that's a tricky one! We were thinking how to do it correctly and I think we will add a "collapse" function to the code editor on mobile, so you'll be able to collapse / expand it on demand. Would it work for you?

Hi, I'm Wojciech, one of the founders of Enso (https://enso.org) :)

SEE THE DEMO HERE: https://www.youtube.com/watch?v=fQvWMoOjmQk&ab_channel=Enso

What is Enso? Enso is an award-winning interactive programming language with dual visual and textual representations. It is a tool that spans the entire stack, going from high-level visualization and communication to the nitty-gritty of backend services, all in a single language. Enso is also a polyglot language - it lets you import any library from Enso, Java, JavaScript, R, or Python, and use functions, callbacks, and data types without any wrappers. The Enso compiler and the underlying GraalVM JIT compiler, compile them to the same instruction set with a unified memory model.

What is this post about? Enso has visual and textual syntax. We have released Enso 2.0 alpha to the public as a free, open-source project over a week ago and we got a lot of questions regarding what is the best way to learn its textual syntax. To address these questions, we have created a dedicated page for it! Check it out here: https://enso.org/docs/syntax

If you want to learn more about Enso, check the following links! - our website: https://enso.org - our GitHub (Enso is Open Source and free to use): https://github.com/enso-org/enso

If you have any questions, I'd love to answer them! <3

Thank you, Jesse. We love https://here.fm as well! <3

Hi, I'm Wojciech, one of Enso founders. I'm excited that Enso 2.0 was just published! I'd love to answer any questions :) Also, check out our Enso intro video: https://www.youtube.com/watch?v=fQvWMoOjmQk

I fully agree that the visual environment should arrange the newly created graph nodes in a nice way automatically. In the Enso 2.0 version we have a very early support implemented exactly for that. However, there is a lot to be done yet to have it working fluently in the case of bigger and complex graphs. It is a fascinating research topic for me, TBH.

Thank you for nice words! <3

Paul, its such an honor to see your reply here! I'm a big fan of your work and your Flow-Based Programming book. It was one of the most important inspirations to what I'm doing in my life now (Enso: https://www.youtube.com/channel/UC4oMK7cL1ElfNR_OhS-YQAw). I truly love the arguments that you use there and how you describe how visual programming can unlock the communication between users of different backgrounds (business people, developers, etc).

To be honest, I was thinking about contacting you, Paul, for a long time already, however, I always felt like we are not yet in the stage of the development to bother you. Right now, when we are very close to Enso 2.0 public release, I would truly love to spend an hour with you on a call – I'll write an email to you about it and I hope you'll agree to chat with us! :)

@djder thanks for referring to us (Enso)! The topic you mentioned - leaving the graph structure (layout?) entirely up to the user - why do you feel it is a bad choice? In our experience (strongly influenced by VFX tools, like Sidefx Houdini), people are designing the 2D workspace similar to how you structure your code. For example, "on left top corner we will have database filtering", "on right bottom space we will have credit risk analysis". This way authors of workflows are able to navigate trough hierarchical graphs really, really fast, knowing where are things they have designed. With auto-generated layouts, the layout can change drastically when you apply even small semantic changes (like when you pass a new parameter between two nodes), and thus, it will break this mental space-mapping between nodes positions and their responsivities.

Anyway, we are building Enso in a completely open way, allowing third-party auto-layouting algorithms to manage the graph visual layout, and we are very open to investigate it further - that's why I asked this question :)