Lisp HUG Maillist Archive

Apply Changes Tool

When I’m developing a new release of a Lisp project I tend to keep the old and new versions of each function in the sources, prefixed with #-new and #+new, so I can test either version with (push :new *features*).

Then when I’m happy with the new version I go through my source files stripping out the #-new versions of each function, and the #+new prefixes.

What I’m wondering is whether there’s an existing Lisp tool to do this automatically on a folder of source files?

Thanks,
David

+------------------------------------------------------------+
David Johnson-Davies, Human-Computer Interface Ltd
17 Signet Court, Swanns Road, Cambridge, CB5 8LA, England.

Tel: +44 1223 314934, Fax: +44 1223 462562
Email: david@interface.co.uk, Web: http://www.interface.co.uk/
+------------------------------------------------------------+


_______________________________________________
Lisp Hug - the mailing list for LispWorks users
lisp-hug@lispworks.com
http://www.lispworks.com/support/lisp-hug.html


Re: Apply Changes Tool

I've always used branching in source control with diff. Git makes this very easy.

Keith
On Tue, Mar 8, 2016 at 9:10 AM David Johnson-Davies <david@interface.co.uk> wrote:

When I’m developing a new release of a Lisp project I tend to keep the old and new versions of each function in the sources, prefixed with #-new and #+new, so I can test either version with (push :new *features*).

Then when I’m happy with the new version I go through my source files stripping out the #-new versions of each function, and the #+new prefixes.

What I’m wondering is whether there’s an existing Lisp tool to do this automatically on a folder of source files?

Thanks,
David

+------------------------------------------------------------+
David Johnson-Davies, Human-Computer Interface Ltd
17 Signet Court, Swanns Road, Cambridge, CB5 8LA, England.

Tel: +44 1223 314934, Fax: +44 1223 462562
Email: david@interface.co.uk, Web: http://www.interface.co.uk/
+------------------------------------------------------------+


_______________________________________________
Lisp Hug - the mailing list for LispWorks users
lisp-hug@lispworks.com
http://www.lispworks.com/support/lisp-hug.html

RE: Apply Changes Tool

Agreed with Keith.

 

Over the years, I have used source control with external tools for branching and system release. In the early years, it was simplistic sccs, moved on to svn, and am now using Git for the little programming I still do.

 

For my old Lisp code (on a Symbolics Lisp Machine … I am dating myself!), I used a manual approach. Simply copied all the source files into new directories for each release. Sloppy, but it worked fine – particularly because changes to any single function was easy enough to test in the overall system very quickly.

 

(BTW, I have yet to find as superior a development environment as what I used on a Symbolics 3600 in the 1980’s … I miss those systems … highly productive development environment!)

 

Z

 

From: owner-lisp-hug@lispworks.com [mailto:owner-lisp-hug@lispworks.com] On Behalf Of Keith Corbett
Sent: Wednesday, March 9, 2016 04:19 AM
To: David Johnson-Davies <david@interface.co.uk>; Lispworks HUG <lisp-hug@lispworks.com>
Subject: Re: Apply Changes Tool

 

I've always used branching in source control with diff. Git makes this very easy.

Keith

On Tue, Mar 8, 2016 at 9:10 AM David Johnson-Davies <david@interface.co.uk> wrote:


When I’m developing a new release of a Lisp project I tend to keep the old and new versions of each function in the sources, prefixed with #-new and #+new, so I can test either version with (push :new *features*).

Then when I’m happy with the new version I go through my source files stripping out the #-new versions of each function, and the #+new prefixes.

What I’m wondering is whether there’s an existing Lisp tool to do this automatically on a folder of source files?

Thanks,
David

+------------------------------------------------------------+
David Johnson-Davies, Human-Computer Interface Ltd
17 Signet Court, Swanns Road, Cambridge, CB5 8LA, England.

Tel: +44 1223 314934, Fax: +44 1223 462562
Email: david@interface.co.uk, Web: http://www.interface.co.uk/
+------------------------------------------------------------+


_______________________________________________
Lisp Hug - the mailing list for LispWorks users
lisp-hug@lispworks.com
http://www.lispworks.com/support/lisp-hug.html

Re: Apply Changes Tool

I feel the same, but with the old Interlisp-D environment :)
esp on a 36-bit Dorado!



On 3/9/2016 11:14 PM, Syed Zaeem Hosain wrote:

Agreed with Keith.

 

Over the years, I have used source control with external tools for branching and system release. In the early years, it was simplistic sccs, moved on to svn, and am now using Git for the little programming I still do.

 

For my old Lisp code (on a Symbolics Lisp Machine … I am dating myself!), I used a manual approach. Simply copied all the source files into new directories for each release. Sloppy, but it worked fine – particularly because changes to any single function was easy enough to test in the overall system very quickly.

 

(BTW, I have yet to find as superior a development environment as what I used on a Symbolics 3600 in the 1980’s … I miss those systems … highly productive development environment!)

 

Z

 

From: owner-lisp-hug@lispworks.com [mailto:owner-lisp-hug@lispworks.com] On Behalf Of Keith Corbett
Sent: Wednesday, March 9, 2016 04:19 AM
To: David Johnson-Davies <david@interface.co.uk>; Lispworks HUG <lisp-hug@lispworks.com>
Subject: Re: Apply Changes Tool

 

I've always used branching in source control with diff. Git makes this very easy.

Keith

On Tue, Mar 8, 2016 at 9:10 AM David Johnson-Davies <david@interface.co.uk> wrote:


When I’m developing a new release of a Lisp project I tend to keep the old and new versions of each function in the sources, prefixed with #-new and #+new, so I can test either version with (push :new *features*).

Then when I’m happy with the new version I go through my source files stripping out the #-new versions of each function, and the #+new prefixes.

What I’m wondering is whether there’s an existing Lisp tool to do this automatically on a folder of source files?

Thanks,
David

+------------------------------------------------------------+
David Johnson-Davies, Human-Computer Interface Ltd
17 Signet Court, Swanns Road, Cambridge, CB5 8LA, England.

Tel: +44 1223 314934, Fax: +44 1223 462562
Email: david@interface.co.uk, Web: http://www.interface.co.uk/
+------------------------------------------------------------+


_______________________________________________
Lisp Hug - the mailing list for LispWorks users
lisp-hug@lispworks.com
http://www.lispworks.com/support/lisp-hug.html


RE: Apply Changes Tool

Hmmm … yes, you have a point. Although I might sugggest, as a good implementation of some part of your thoughts, check out the following: https://www.sourcetreeapp.com/

 

This is a free “visual” tool that works with Git (and Mercurial) and is quite useful.

 

Z

 

From: Pascal Bourguignon [mailto:pjb@informatimago.com]
Sent: Thursday, March 10, 2016 04:47 PM
To: Syed Zaeem Hosain <Syed.Hosain@aeris.net>
Cc: Keith Corbett <kmcorbett@gmail.com>; David Johnson-Davies <david@interface.co.uk>; Lispworks HUG <lisp-hug@lispworks.com>
Subject: Re: Apply Changes Tool

 

But let's be honest, external tools such as git, even when integrated in emacs or other IDE are too coarse and with worse UI than commented out source code.

 

What we'd want is an UI where you can see two or more successive versions (or selected versions) of a function or a selected set of sexps and edit them (creating automatically a new version). The IDE could use git in the background to scan the changes and successive versions and to create new ones (so with automatic commit, it would have to be smart about them).  The displaying of the versions in the buffer can use multiple forms (side by side, sequential, stacked with transparency or time slider, etc).

 

Probably a firat step into such a tool would be to have the IDE manage storing the top level forms in files automatically, with minimal instruction from the user, so it may start to do the versionning on a sexp basis instead of a file basis.

-- 

__Pascal Bourguignon__


On 10 Mar 2016, at 08:14, Syed Zaeem Hosain <Syed.Hosain@aeris.net> wrote:

Agreed with Keith.

 

Over the years, I have used source control with external tools for branching and system release. In the early years, it was simplistic sccs, moved on to svn, and am now using Git for the little programming I still do.

 

For my old Lisp code (on a Symbolics Lisp Machine … I am dating myself!), I used a manual approach. Simply copied all the source files into new directories for each release. Sloppy, but it worked fine – particularly because changes to any single function was easy enough to test in the overall system very quickly.

 

(BTW, I have yet to find as superior a development environment as what I used on a Symbolics 3600 in the 1980’s … I miss those systems … highly productive development environment!)

 

Z

 

From: owner-lisp-hug@lispworks.com [mailto:owner-lisp-hug@lispworks.com] On Behalf Of Keith Corbett
Sent: Wednesday, March 9, 2016 04:19 AM
To: David Johnson-Davies <david@interface.co.uk>; Lispworks HUG <lisp-hug@lispworks.com>
Subject: Re: Apply Changes Tool

 

I've always used branching in source control with diff. Git makes this very easy.

Keith

On Tue, Mar 8, 2016 at 9:10 AM David Johnson-Davies <david@interface.co.uk> wrote:


When I’m developing a new release of a Lisp project I tend to keep the old and new versions of each function in the sources, prefixed with #-new and #+new, so I can test either version with (push :new *features*).

Then when I’m happy with the new version I go through my source files stripping out the #-new versions of each function, and the #+new prefixes.

What I’m wondering is whether there’s an existing Lisp tool to do this automatically on a folder of source files?

Thanks,
David

+------------------------------------------------------------+
David Johnson-Davies, Human-Computer Interface Ltd
17 Signet Court, Swanns Road, Cambridge, CB5 8LA, England.

Tel: +44 1223 314934, Fax: +44 1223 462562
Email: david@interface.co.uk, Web: http://www.interface.co.uk/
+------------------------------------------------------------+


_______________________________________________
Lisp Hug - the mailing list for LispWorks users
lisp-hug@lispworks.com
http://www.lispworks.com/support/lisp-hug.html

Re: Apply Changes Tool

I use Sourcetree every day (albeit not for Lisp, sadly) and it is a very very good tool for diff visualisation and merge conflict resolution.

*THE* tool would be something like the Smalltalk changeset browser but worked into Lispworks IDE, maybe using 'git' as the underlying difference management engine?

I've used Leo editor on a number of projects over the years and found that to be very very useful but it is still hard to make it work on OSX as it is Qt bound.

Sean.

On 11 March 2016 at 07:20, Syed Zaeem Hosain <Syed.Hosain@aeris.net> wrote:

Hmmm … yes, you have a point. Although I might sugggest, as a good implementation of some part of your thoughts, check out the following: https://www.sourcetreeapp.com/

 

This is a free “visual” tool that works with Git (and Mercurial) and is quite useful.

 

Z

 

From: Pascal Bourguignon [mailto:pjb@informatimago.com]
Sent: Thursday, March 10, 2016 04:47 PM
To: Syed Zaeem Hosain <Syed.Hosain@aeris.net>
Cc: Keith Corbett <kmcorbett@gmail.com>; David Johnson-Davies <david@interface.co.uk>; Lispworks HUG <lisp-hug@lispworks.com>


Subject: Re: Apply Changes Tool

 

But let's be honest, external tools such as git, even when integrated in emacs or other IDE are too coarse and with worse UI than commented out source code.

 

What we'd want is an UI where you can see two or more successive versions (or selected versions) of a function or a selected set of sexps and edit them (creating automatically a new version). The IDE could use git in the background to scan the changes and successive versions and to create new ones (so with automatic commit, it would have to be smart about them).  The displaying of the versions in the buffer can use multiple forms (side by side, sequential, stacked with transparency or time slider, etc).

 

Probably a firat step into such a tool would be to have the IDE manage storing the top level forms in files automatically, with minimal instruction from the user, so it may start to do the versionning on a sexp basis instead of a file basis.

-- 

__Pascal Bourguignon__


On 10 Mar 2016, at 08:14, Syed Zaeem Hosain <Syed.Hosain@aeris.net> wrote:

Agreed with Keith.

 

Over the years, I have used source control with external tools for branching and system release. In the early years, it was simplistic sccs, moved on to svn, and am now using Git for the little programming I still do.

 

For my old Lisp code (on a Symbolics Lisp Machine … I am dating myself!), I used a manual approach. Simply copied all the source files into new directories for each release. Sloppy, but it worked fine – particularly because changes to any single function was easy enough to test in the overall system very quickly.

 

(BTW, I have yet to find as superior a development environment as what I used on a Symbolics 3600 in the 1980’s … I miss those systems … highly productive development environment!)

 

Z

 

From: owner-lisp-hug@lispworks.com [mailto:owner-lisp-hug@lispworks.com] On Behalf Of Keith Corbett
Sent: Wednesday, March 9, 2016 04:19 AM
To: David Johnson-Davies <david@interface.co.uk>; Lispworks HUG <lisp-hug@lispworks.com>
Subject: Re: Apply Changes Tool

 

I've always used branching in source control with diff. Git makes this very easy.

Keith

On Tue, Mar 8, 2016 at 9:10 AM David Johnson-Davies <david@interface.co.uk> wrote:


When I’m developing a new release of a Lisp project I tend to keep the old and new versions of each function in the sources, prefixed with #-new and #+new, so I can test either version with (push :new *features*).

Then when I’m happy with the new version I go through my source files stripping out the #-new versions of each function, and the #+new prefixes.

What I’m wondering is whether there’s an existing Lisp tool to do this automatically on a folder of source files?

Thanks,
David

+------------------------------------------------------------+
David Johnson-Davies, Human-Computer Interface Ltd
17 Signet Court, Swanns Road, Cambridge, CB5 8LA, England.

Tel: +44 1223 314934, Fax: +44 1223 462562
Email: david@interface.co.uk, Web: http://www.interface.co.uk/
+------------------------------------------------------------+


_______________________________________________
Lisp Hug - the mailing list for LispWorks users
lisp-hug@lispworks.com
http://www.lispworks.com/support/lisp-hug.html


Re: Apply Changes Tool

I wonder how easy it would be to subvert a Squeak Smalltalk class browser to allow for Lisp friendly code editing?!?!

The change-set browser should automatically just do the right thing.

The only work I see would be to prevent the standard compile-on-save behaviour and instead maybe change it to a request to a running swank server or something to recompile that function / perform macro expansion.

Shame I haven't touched Squeak for a good five years or so.

Just a thought. The Smalltalk IDE is superb and would probably make a good fit for Lisp. Maybe.

:)
Sean


On 11 March 2016 at 08:16, emacstheviking <objitsu@gmail.com> wrote:
I use Sourcetree every day (albeit not for Lisp, sadly) and it is a very very good tool for diff visualisation and merge conflict resolution.

*THE* tool would be something like the Smalltalk changeset browser but worked into Lispworks IDE, maybe using 'git' as the underlying difference management engine?

I've used Leo editor on a number of projects over the years and found that to be very very useful but it is still hard to make it work on OSX as it is Qt bound.

Sean.

On 11 March 2016 at 07:20, Syed Zaeem Hosain <Syed.Hosain@aeris.net> wrote:

Hmmm … yes, you have a point. Although I might sugggest, as a good implementation of some part of your thoughts, check out the following: https://www.sourcetreeapp.com/

 

This is a free “visual” tool that works with Git (and Mercurial) and is quite useful.

 

Z

 

From: Pascal Bourguignon [mailto:pjb@informatimago.com]
Sent: Thursday, March 10, 2016 04:47 PM
To: Syed Zaeem Hosain <Syed.Hosain@aeris.net>
Cc: Keith Corbett <kmcorbett@gmail.com>; David Johnson-Davies <david@interface.co.uk>; Lispworks HUG <lisp-hug@lispworks.com>


Subject: Re: Apply Changes Tool

 

But let's be honest, external tools such as git, even when integrated in emacs or other IDE are too coarse and with worse UI than commented out source code.

 

What we'd want is an UI where you can see two or more successive versions (or selected versions) of a function or a selected set of sexps and edit them (creating automatically a new version). The IDE could use git in the background to scan the changes and successive versions and to create new ones (so with automatic commit, it would have to be smart about them).  The displaying of the versions in the buffer can use multiple forms (side by side, sequential, stacked with transparency or time slider, etc).

 

Probably a firat step into such a tool would be to have the IDE manage storing the top level forms in files automatically, with minimal instruction from the user, so it may start to do the versionning on a sexp basis instead of a file basis.

-- 

__Pascal Bourguignon__


On 10 Mar 2016, at 08:14, Syed Zaeem Hosain <Syed.Hosain@aeris.net> wrote:

Agreed with Keith.

 

Over the years, I have used source control with external tools for branching and system release. In the early years, it was simplistic sccs, moved on to svn, and am now using Git for the little programming I still do.

 

For my old Lisp code (on a Symbolics Lisp Machine … I am dating myself!), I used a manual approach. Simply copied all the source files into new directories for each release. Sloppy, but it worked fine – particularly because changes to any single function was easy enough to test in the overall system very quickly.

 

(BTW, I have yet to find as superior a development environment as what I used on a Symbolics 3600 in the 1980’s … I miss those systems … highly productive development environment!)

 

Z

 

From: owner-lisp-hug@lispworks.com [mailto:owner-lisp-hug@lispworks.com] On Behalf Of Keith Corbett
Sent: Wednesday, March 9, 2016 04:19 AM
To: David Johnson-Davies <david@interface.co.uk>; Lispworks HUG <lisp-hug@lispworks.com>
Subject: Re: Apply Changes Tool

 

I've always used branching in source control with diff. Git makes this very easy.

Keith

On Tue, Mar 8, 2016 at 9:10 AM David Johnson-Davies <david@interface.co.uk> wrote:


When I’m developing a new release of a Lisp project I tend to keep the old and new versions of each function in the sources, prefixed with #-new and #+new, so I can test either version with (push :new *features*).

Then when I’m happy with the new version I go through my source files stripping out the #-new versions of each function, and the #+new prefixes.

What I’m wondering is whether there’s an existing Lisp tool to do this automatically on a folder of source files?

Thanks,
David

+------------------------------------------------------------+
David Johnson-Davies, Human-Computer Interface Ltd
17 Signet Court, Swanns Road, Cambridge, CB5 8LA, England.

Tel: +44 1223 314934, Fax: +44 1223 462562
Email: david@interface.co.uk, Web: http://www.interface.co.uk/
+------------------------------------------------------------+


_______________________________________________
Lisp Hug - the mailing list for LispWorks users
lisp-hug@lispworks.com
http://www.lispworks.com/support/lisp-hug.html



Updated at: 2020-12-10 08:32 UTC