I emphasized ASDF in this particular announcement because it's the topic here, and ASDF is an important part of Seed's stack. The most ASDF-relevant module is this one:

https://github.com/phantomics/seed/blob/master/seed.generate/generate.lisp

The seed.generate package is the core of Seed, and its sprout class wraps ASDF systems. The describe-as-asdf-system method generates a system definition from a sprout. This method parses the I/O specification of a Seed system to generate the ASDF system.

You can see how the I/O specification works in these files.

https://github.com/phantomics/seed/blob/master/demo-drawing/demo-drawing.see... https://github.com/phantomics/seed/blob/master/demo-sheet/demo-sheet.seed

They are my extension to the ASDF model for defining systems. Their :system property is ported directly to the ASDF definition, while the content of the :branches specification also contributes.

I built the slides with the OSX application Keynote. The graphical elements were made in different ways. Some are screenshots of the Seed interface and experimental Seed extensions, some of which I scaled up or changed in other ways through the browser console, like by removing text content to emphasize the layout. Designs like the ones on pages 1 and 15 are SVG graphics done in Inkscape.

Andrew

On 11/01/2017 03:19 PM, Faré wrote:

Looks cool and interesting, and the code looks clean, too (though maybe you should read and take to heart my "asdf best practices" document currently at https://github.com/fare/asdf/blob/master/doc/best_practices.md ).

I'm not sure how ASDF fits in it and that it deserves such prominent part in your annoucement (unless you swap out that part when announcing on other venues, which you should if you didn't yet). Where are your ASDF extensions defined?

However I don't have time to look in detail right now. Still, what technology did you use to produce those slides? They are neat.

—♯ƒ • François-René ÐVB Rideau •Reflection&Cybernethics• http://fare.tunes.org Government is a disease masquerading as its own cure. — Robert LeFevre (1911-1986)

On Wed, Nov 1, 2017 at 5:55 PM, Andrew Sengul ml@imagegardenphoto.com wrote:

...

Hi everyone,

I've created a new software environment based on Common Lisp and it'd be great to get your feedback. Called Seed, this system can be used to create Lisp programs and interact with them in many ways. It's a bit like a web-based IDE, but unlike most IDEs, it uses a visual programming language as its foundation.

Seed displays Lisp code in the form of an interactive tree grid. It's possible to create customized interface elements within the tree grid; these elements are converted into Lisp code for compilation. A simple example is a color picker for use choosing colors inside a HTML template. Drop-downs and toggle switches are also easy to insert, and these elements can be composited to create more sophisticated interfaces. And unlike Emacs and other editors that are designed around text files, Seed is designed around editing ASDF systems.

When using Seed, the top-level interactive elements are called "systems"

• contrast to "buffers" in Emacs. Each Seed system is an ASDF system

with particular extensions. Specifically, Seed systems all have a .seed file in their source directory that defines their behavior within the scope of the Seed environment.

Check out this video to see Seed in action and a brief tutorial:

https://vimeo.com/237947324

This is a slide deck that goes into further detail:

https://www.dropbox.com/s/ssjd05bmrfnzg5e/SeedPresentationTechnical.pdf?dl=0

I don't know if Seed is the first general-purpose visual programming environment, but I'm sure its paradigm is among the most flexible. It is implemented as a Web application, with each atom and form within a Lisp program represented by a module manifested using the React framework for JavaScript. Because Seed's interface is implemented in React, the entire ecosystem of React components can be brought to bear when building custom software interfaces.

Ready to try Seed out yourself? It's free software and the repo is here:

https://github.com/phantomics/seed

The installation instructions start here:

https://github.com/phantomics/seed#the-first-step-installing-and-running-see...

Read the usage tutorial here:

https://github.com/phantomics/seed/wiki/Introductory-Tutorial

So far, only SBCL has been tested. This is alpha software and you will encounter bugs aplenty.

I envision Seed as something that could one day encompass most of the desktop productivity functions that people now use office apps for. The data-driven nature of the interface will make it easy to mash up and modify these tools to design custom workflows.With Lisp's homoiconicity it may even be possible to develop machine learning algorithms to tailor Seed systems to the jobs they're intended to do. Emacs has always been seen as the flagship of Lisp-based environments, but because of its byzantine interface and its tight coupling to the text buffer as the main interactive unit, I can't see a future where Emacs is usable by regular people for desktop productivity. I think Seed may be able to get there.

Let me know what you think of Seed, particularly as an ASDF use case. Best,

Andrew Sengul

On 11/01/2017 07:00 PM, Faré wrote:

...

The most ASDF-relevant module is this one: https://github.com/phantomics/seed/blob/master/seed.generate/generate.lisp

The seed.generate package is the core of Seed, and its sprout class wraps ASDF systems. The describe-as-asdf-system method generates a system definition from a sprout. This method parses the I/O specification of a Seed system to generate the ASDF system.

What is the granularity of your seeds?

I'm not sure what you mean, by granularity are you referring to the size of the minimum viable Seed system? It could be just a folder containing an .asd file and a .seed file. You'd probably want a .lisp source file in there to do much of anything interesting. Less orthodox arrangements could work too.

When I first joined this list in July 2016 I asked a question about the possibility of using ASDF to build systems with source code that didn't come in files but from lists stored in variables in the running Lisp instance. Implementing a feature like that would make Seed more flexible.

...

You can see how the I/O specification works in these files. https://github.com/phantomics/seed/blob/master/demo-drawing/demo-drawing.see... https://github.com/phantomics/seed/blob/master/demo-sheet/demo-sheet.seed

I admit the semantics is not obvious. Maybe some documentation could help. Otherwise, the code looks very clean, but I really don't have time for it now. Thanks for advertising on the list, though -- your announcement is most welcome.

I understand, the I/O spec definitely needs documentation. When you have time, you may get some understanding of how the system works by reading the definitions for the I/O media here:

https://github.com/phantomics/seed/blob/master/seed.media.base/media.base.li...

Each of the media has a comment that describes what it does. And to understand how these specifications are used, take a look at the big "till" macro in seed.generate/generate.lisp.

The main thing to understand is that it's a dataflow language. Each successive form like (set-time) and (codec) is passed the input data, does something to it and passes it to the next form in the list. So the till macro transforms something like "(set-time) (do-something) (codec)" to "(codec (do-something (set-time original-data)))." With this language, I can implement things like clipboards and undo history in unique ways for different systems.

...

I built the slides with the OSX application Keynote. The graphical elements were made in different ways. Some are screenshots of the Seed interface and experimental Seed extensions, some of which I scaled up or changed in other ways through the browser console, like by removing text content to emphasize the layout. Designs like the ones on pages 1 and 15 are SVG graphics done in Inkscape.

Thanks.

BTW, are you around NYC or are you passing by in 2018? You could give a talk at Lisp NYC.

I'm located on the West Coast but I could be over there sometime; that would be great. Thanks for your feedback,

Andrew

On 11/02/2017 02:12 AM, Faré wrote:

I'm a bit confused. Is it a Lisp DSL, a graphical programming system, the two next to each other, or the two at the same time, etc.? When you program graphically, how do you specify the division in files and/or systems?

Seed is an interactive programming system that uses graphics more than mainstream programming tools. I wouldn't say it's purely a graphical system since you could use it with a text-based interface, but it's much more graphical than your standard IDE. Seed uses DSLs to define some parts of itself, and it makes a few key extensions to Lisp like the (meta) macro that are needed for it to work.

The translation of the graphical interface to files and systems is defined by the I/O spec language, one of Seed's main DSLs. Look at https://github.com/phantomics/seed/blob/master/demo-sheet/demo-sheet.seed and you'll see these forms:

1. (put-file (table-specs (get-file :-self)) :-self) 2. (put-file (sheet-content (get-file :main)) :main)

Form 1 is under the (main) branch and Form 2 is under the (cells) branch. If you watch the demo video, you'll see the "main" and "cells" branches in the visual display of the spreadsheet interface. The meaning of Form 1 is "take the input to the main branch, combine it with the content of the "main.lisp" file using the "table-specs" I/O medium, then save the resulting data to the "main.lisp" file.

Where does the "main.lisp" filename come from in Form 1? Notice that the second argument to put-file and the first argument to get-file is :-self. When the :-self argument is present, the name of the branch ("main" in this case) is string-downcased and has ".lisp" appended to it.

In Form 2, instead of using the name of the branch ("sheet") the keyword :main is used, which is converted to "main.lisp." If you look at https://github.com/phantomics/seed/blob/master/demo-sheet/main.lisp, you'll see that both the data for the spreadsheet cells and the cell-manipulating forms from the left column are represented there. In this branch, the "sheet-content" medium is used to convert between the format for stored spreadsheet data and the format used in the spreadsheet interface.

So Seed's interface can have any kind of file structure behind it. In this case, I use two different interface branches to interact with a single Lisp file. I could also have a dozen different files downstream from a single interface branch.

One of Seed's core ideas is that programming interface elements should be "self-actualized" and not tied to arbitrary structures like text buffers. The interface branches may have relationships with text files, remote APIs and other things but they are not defined by them. Seed makes it easy to create "views" of code; for instance, you could have a display mode where you are shown a function at the beginning of the code display followed by every other function in the software system that calls that first function, regardless of what file it's specified in. You could also create a view for a function and its unit tests.

Implementing things like this would be much harder in Emacs since Emacs is still tightly coupled to the concept of the text buffer as the main interactive element. The self-actualized nature of Seed's interface branches is the reason that they are amenable to graphical programming and other atypical modes of interaction.

Let me know if this makes sense. By the way, if you'd like to learn more I've been doing 1-on-1 workshops with developers to show them the basics of using and extending Seed, either in person or via screen share. The latter option would probably work best for you if you're interested.

...

The main thing to understand is that it's a dataflow language. Each successive form like (set-time) and (codec) is passed the input data, does something to it and passes it to the next form in the list. So the till macro transforms something like "(set-time) (do-something) (codec)" to "(codec (do-something (set-time original-data)))." With this language, I can implement things like clipboards and undo history in unique ways for different systems.

Reminds me of my uiop:nest macro. https://fare.livejournal.com/189741.html More seriously, congrats, it really looks neat at first glance.

That's cool. In my case I'm reversing the order of expansion as well as adding the implicit input, so (a) (b) (c) expands to (c (b (a input))). This makes it more intuitive to specify long series of media. Also, it's possible to assign two different possible expansions to an I/O medium depending on if it's taking input or output. So inside the (in) form, (a) will do something different than it does inside the (out) form since it's handling input rather than output.

Andrew