Hello,
time for the thirteenth Online Lisp Meeting!
We'll have David Botton who will talk about CLOG, the Page vs Screen
Approach to the Web, and the new CLOG GUI Builder Tool.
> The Common Lisp Omnificent GUI, CLOG for short, uses web technology to
> produce graphical user interfaces for applications locally or
> remotely. CLOG can take the place, or work alongside, most
> cross-platform GUI frameworks and website frameworks. To help
> understand CLOG better the Page vs Screen approache to web development
> are illustrated. Also a first look at the CLOG GUI Builder.
Date/time/location:
* Date: Tue 11th January 2022
* Time: 18:00 CET - https://time.is/en/CET // 12:00 ET -
https://time.is/en/ET
* Talk: https://www.twitch.tv/TwitchPlaysCommonLisp
A mailing list has been created for the purpose of organizing and
promoting the online talks. Further announcements will be posted there.
See https://mailman.common-lisp.net/listinfo/online-lisp-meets
New videos always welcome! (Unless you are preparing your next big thing
for the next ELS and you do not want to make spoilers.)
Calendar invitations will follow in replies to this mail.
BR and see you,
Michał "phoe" Herda
Hello,
I hope you haven't forgotten about the Meetings. I sure haven't! Time to
organize yet another one, or even two - since I got two videos, one
right after the other. The announcement for the second meeting will come
tomorrow though; let's focus on the first one for now!
This time, we'll have Jan Moringen talking about a modern (and already
rather successful!) approach to parsing the holy scriptures of Common
Lisp - the language specification in its TeX source format.
> The most important specification documents for the Common Lisp
> programming language, namely the Common Lisp ANSI standard and the
> Common Lisp HyperSpec (CLHS), are both provided under restrictive
> licenses (and at a cost in case of ANSI). This situation prevents the
> creation and distribution of derived works such as alternative
> presentations or corrected revisions. This inability to produce
> derived works has lead to the creation of independent errata lists
> that cannot be "applied" to the specification.
>
> Despite these obstacles, a way forward, albeit one that involves lots
> of effort, has been known for some time: start from the TeX sources of
> the draft specification ("dpANS"), which are in the public domain, and
> create new specification documents. Those documents can then improve
> on the hyperlinking and presentation of the CLHS as well as
> incorporate corrections. The high effort associated with this
> approach comes from the fact that the tools that were used to create
> the CLHS are not publicly available.
>
> This presentation explains the situation outlined above in more detail
> and introduces our project to create the required tools and produce
> new specification documents from the dpANS TeX sources and X3J13
> cleanup issue files. After mentioning some of the problems in the
> draft specification as well as the CLHS that we plan to address, we
> present our method for parsing and processing the sources. After
> that, we show current and future applications of the parsing,
> transformation and generation process. We conclude by sharing open
> problems as well as a call to action aimed at re-discovering the most
> recent versions of the X3J13 issue files which we, so far, did not
> manage to find anywhere.
A short Jitsi talk with everyone will happen just after the meeting.
Where and when exactly - I'll link it in a follow-up mail.
Date/time/location:
* Date: 17th December 2021
* Time: 12:00 CET - https://time.is/en/CET
* Talk: https://www.twitch.tv/TwitchPlaysCommonLisp
A mailing list has been created for the purpose of organizing and
promoting the online talks. Further announcements will be posted there.
See https://mailman.common-lisp.net/listinfo/online-lisp-meets
New videos welcome! If you have anything lispy that you would like to
talk about, please let me know.
Calendar invitations will follow in replies to this mail.
BR and see you,
Michał "phoe" Herda
Hey everyone,
this is a small announcement from me, the person responsible for
organizing the Online Lisp Meetings throught the previous year.
I have not had much success so far with collecting videos after this
year's ELS to be played during Online Lisp Meetings yet (and I blame
preparing and shipping the post-ELS calligraphy for that) - hence point
1 of the below mail. Still, it seems that the general need to discuss
fresh Lisp stuff and the need to watch fresh Lisp stuff lives on, hence
point 2 of the below mail!
1) If you would like to talk about anything that you find interesting
and is is any way lispy, please let me know in any way. I'll want you to
give me an abstract of the talk a week before the planned playback date,
and to record a video for us all to view on Twitch 48 hours before the
playback. The talk format is more or less freeform with a soft limit at
60 minutes of length.
2) The Boston Lisp Meeting returns on Thursday June 10th 2020 at 6:00 PM
(Boston Time, I assume) with two talks about MPS in SBCL and the current
state of Dylan! Please follow them at
https://common-lisp.net/project/boston-lisp/ and, despite the time
difference for us Europeans, I hope to see you there!
Thank you and stay healthy during these tough times,
Michał "phoe" Herda
Hello!
We've had about a month of breathing room since the tenth Online Lisp
Meeting. Ready for the next ten?
I allowed myself to occupy the slot for the eleventh meeting. I will
talk about the basics of control flow in Common Lisp and how the
primitives exposed by Common Lisp (IF, TAGBODY/GO, BLOCK/RETURN-FROM,
CATCH/THROW, UNWIND-PROTECT, FUNCTION/APPLY) can be used to implement
various control flow structures - including the ones constituting the
parts of Common Lisp condition system that, indeed, perform transfers of
control. We will have a gentle introduction to all of the primitives
that we'll use, so even non-CL programmers should feel at home.
A short Jitsi talk with everyone will happen just after the meeting, too!
Date/time/location:
* Date: 26th November 2020 (that's Thursday! I can't host Wednesday
meetings for the time being due to work-related duties.)
* Time: 13:00 CEST - https://time.is/en/CEST
* Talk: https://www.twitch.tv/TwitchPlaysCommonLisp
* Hangout: https://chat.heisig.xyz/TwitchPlaysCommonLisp @ 15:00
Massive thanks to Marco Heisig for providing the Jitsi instance where we
can hang out after the talk.
A mailing list has been created for the purpose of organizing and
promoting the online talks. Further announcements will be posted there.
See https://mailman.common-lisp.net/listinfo/online-lisp-meets
New videos welcome! If you have anything lispy that you would like to
talk about, please let me know.
Calendar invitations will follow in replies to this mail.
BR and see you,
Michał "phoe" Herda
Hello!
I have the pleasure of announcing the Ath Online Lisp Meeting (counting
in hexadecimal, obviously).
We will have Jan Moringen speaking about Eclector, the extensible and
portable Common Lisp reader.
> The Common Lisp reader is a collection of functions and variables for
> turning sequences of characters into s-expressions, which are
> described in Chapter 2 of the specification. While some aspects of the
> behavior of the reader can be customized, many parts are internal to
> each Common Lisp implementation and thus inaccessible to portable
> programs. Eclector is a portable reader implementation which is set
> apart by 1) providing very detailed error reporting (for humans and
> programs) 2) allowing recovery from (almost) all syntax errors 3)
> allowing customization of far more aspects than other readers 4)
> providing a mechanism for constructing parse results with source
> information. This presentation introduces the Eclector project and
> explains the customization mechanisms built into its architecture.
> Everything is considered from the perspective of a user of the Elector
> reader, so its implementation is not discussed. The features
> mentioned above are further illustrated in several (hopefully)
> interesting and useful demonstrations.
A short Jitsi talk with everyone will happen just after the meeting.
Date/time/location:
* Date: 7th October 2020
* Time: 13:00 CEST - https://time.is/en/CEST
* Talk: https://www.twitch.tv/TwitchPlaysCommonLisp
* Hangout: https://chat.heisig.xyz/TwitchPlaysCommonLisp @ 14:30
Massive thanks to Marco Heisig for providing the Jitsi instance where we
can hang out after the talk.
A mailing list has been created for the purpose of organizing and
promoting the online talks. Further announcements will be posted there.
See https://mailman.common-lisp.net/listinfo/online-lisp-meets
If you'd like to talk about anything that is Lisp-related, please let me
know, and I'll gladly host your video for our small, but very enjoyable,
audience. And then upload it to YouTube for broader posterity.
BR and see you,
Michał "phoe" Herda
Good morning, everyone!
The ninth Online Lisp Meeting will bring us Robert Strandh with his
third installment in the Creating a Common Lisp Implementation series.
> In this series of presentations, we examine different strategies for
> creating a Common Lisp implementation, as well as the pros and cons of
> each strategy.
>
> We assume basic knowledge about how a typical modern operating system
> (such as Unix) works, and how traditional batch languages (such as C)
> are compiled and executed on such a system. We furthermore assume
> medium-level knowledge about Common Lisp.
>
> In part 3, we investigate one possible solution to the conundrum of
> our first strategy outlined in part 2, namely the circular
> compile-time dependencies between many standard macros and standard
> functions, forcing us to write more code in a language other than
> Common Lisp, and also forcing us to write "unnatural" Common Lisp
> code. The solution to this problem is the foundation of our second
> strategy for creating a Common Lisp implementation, and it relies on
> using an existing host Common Lisp implementation for cross
> compilation.
>
> Since some time has passed since part 1 and 2 were streamed, we
> strongly recommend that interested participants make sure that the
> material covered in those two parts is fresh in memory, if necessary
> by watching those presentations again.
A short Jitsi talk with everyone will happen just after the meeting -
everyone is invited!
Date/time/location:
* Date: 16th September 2020
* Time: 13:00 CEST - https://time.is/en/CEST
* Talk: https://www.twitch.tv/TwitchPlaysCommonLisp
* Hangout: https://chat.heisig.xyz/TwitchPlaysCommonLisp @ 14:30
Massive thanks to Marco Heisig for providing the Jitsi instance where we
can hang out after the talk.
A mailing list has been created for the purpose of organizing and
promoting the online talks. Further announcements will be posted there.
See https://mailman.common-lisp.net/listinfo/online-lisp-meets
Lisp videos always accepted! Please let me know if you'd like to talk
about anything Lisp-related.
BR and see you,
Michał "phoe" Herda
Hello, hey, hi, greetings!
I am terribly sorry for posting the announcement for the next Online
Lisp Meeting so late, since it will be in merely two days from now. I
hope that most of you have already got slightly used to the
bi-or-tri-weekly scheme of the Meetings and I am doubly sorry since I
shall need to bend this one as well: I will announce two meetings, the
eight, and the ninth, with just a week of delay between the two. (I will
be unavailable during the rest of September, since life outside Lisp
demands my attention.)
The 2^3th meeting will contain a re-stream of a talk by Andrew Sengul,
who will be presenting April, a compiler from the APL language to Common
Lisp. (The announcement for the 3^2th meeting will come in a separate mail.)
> APL stands for Array Programming Language and, as the name suggests,
> is focused on working with arrays, making it great for for graphics,
> signal processing, statistical work and more.
>
> Using APL within Lisp opens vast possibilities for working with
> structured data. Traditionally, APL is implemented in the form of a
> monolithic interpreter, and feeding data from databases and other
> external APIs into these interpreters and getting the results back in
> a usable format can be daunting.
>
> April is different. Compiling APL expressions into Lisp means that any
> data that can be formatted as a number or character array in Lisp can
> be operated upon using APL. Often, dozens of lines of number-crunching
> code with many nested loops can be replaced by a single line of APL.
> If you're working on a Lisp application that involves many operations
> on arrays or uses complex algorithms in general, April can
> substantially speed up your development process.
>
> In this talk Andrew will recount the trials of developing a new APL
> compiler from scratch and cover some of April's unique advantages,
> including macros that make it easy to extend and modify the language.
>
> This presentation will also feature a sneak preview of Bloxl, a
> hardware startup powered by Common Lisp with April. Bloxl is producing
> a new luminous structural display technology; with Bloxl, you can
> build transparent glass walls that light up with software-controlled
> pixel graphics. You can see more on the Bloxl website at https://bloxl.co.
>
> The original talk that will be restreamed will happen the day before
> (https://www.meetup.com/LispNYC/events/vqhmbpybcmblb/). In order to
> make the talk more accessible to European audiences (the original will
> start at midnight CEST!), I have offered to re-stream the whole talk
> with the ability to chat with the speaker on Twitch, which Andrew has
> accepted.
A short Jitsi talk with everyone will happen just after the meeting -
everyone is invited! (I think it's better to organize those just after
the meetings, because then they actually happen.)
Date/time/location:
Date: 9th September 2020
Time: 13:00 CEST - https://time.is/en/CEST
Talk: https://www.twitch.tv/TwitchPlaysCommonLisp
Hangout: https://chat.heisig.xyz/TwitchPlaysCommonLisp @ 14:30
Massive thanks to Marco Heisig for providing the Jitsi instance where we
can hang out after the talk.
A mailing list has been created for the purpose of organizing and
promoting the online talks. Further announcements will be posted there.
See https://mailman.common-lisp.net/listinfo/online-lisp-meets
More videos welcome - please record and send me anything that you find
interesting and is in any way related to Lisp.
BR and see you!
Michał "phoe" Herda
Good morning, everyone!
Seven seems to be a lucky number for some, and this is the seventh
Online Lisp Meeting. Luckily, more time has solved the problem of the
previous online meeting - we will have a chance to listen to Hayley
Patton's presentation about Techniques and Utilities for Farming Objects
On The Net.
> This presentation is about programming concurrent, distributed systems
> in Common Lisp, and some of the ideas that have sprung up while
> developing the Netfarm distributed object system. We will demonstrate
> how we try to abstract away wire protocol and format differences, how
> we can use a recommender system to filter unwanted content for an end
> user in the Netfarm system; and some libraries we have worked on, with
> the aim to produce performant and robust concurrent Lisp programs.
As before, the talk will be pre-recorded and played back on Twitch, with
the ability to comment on the Twitch chat during playback. The videos
will then make it onto YouTube. And, this time, I plan on organizing a
small virtual hangout *right after* the talk in order to take the
Australian timezones into better account.
Date/time/location:
* Date: 26st August 2020
* Time: 13:00 CEST - https://time.is/en/CEST
* Talk: https://www.twitch.tv/TwitchPlaysCommonLisp
* Hangout: https://chat.heisig.xyz/TwitchPlaysCommonLisp @ 14:30
Massive thanks to Marco Heisig for providing the Jitsi instance where we
can hang out after the talk.
A mailing list has been created for the purpose of organizing and
promoting the online talks. Further announcements will be posted there.
See https://mailman.common-lisp.net/listinfo/online-lisp-meets
More videos welcome - please record and send me anything that you find
interesting and is in any way related to Lisp.
BR and see you!
Michał "phoe" Herda
#.(ALEXANDRIA:RANDOM-ELT *OLM-MAIL-GREETINGS*)
Our speakers for the sixth Online Lisp Meeting are Jan Moringen, a major
SBCL contributor, and Hayley Patton, a Lisp object farmer.
Jan Moringen will talk about Clouseau, a CLIM-based implementation of
the Common Lisp inspector facility.
> An inspector is a software tool the purpose of which is the
> interactive inspection and manipulation of values and their relations
> within a running program. Besides more prominent components such as
> editors and debuggers, inspectors play an important role in
> interactive development environments or just interactive environments
> in general. Common Lisp and Common Lisp-based environments have a
> long history of inspectors: Genera's inspector, CL:INSPECT, the SLIME
> inspector and McCLIM's two inspectors called Clouseau, to name a few.
>
> This presentation is about the latter two: the original Clouseau and,
> more importantly, the redesigned and rewritten implementation that
> replaced it. After mentioning a few crucial requirements and design
> decisions, the presentation focuses on a user's perspective. It
> demonstrates the basic use, specialized visualizations and operations
> and customization of the rewritten Clouseau.
Hayley Patton will talk about Techniques and Utilities for Farming
Objects On The Net.
> This presentation is about programming concurrent, distributed systems
> in Common Lisp, and some of the ideas that have sprung up while
> developing the Netfarm distributed object system. We will demonstrate
> how we try to abstract away wire protocol and format differences, how
> we can use a recommender system to filter unwanted content for an end
> user in the Netfarm system; and some libraries we have worked on, with
> the aim to produce performant and robust concurrent Lisp programs.
As before, the talk will be pre-recorded and played back on Twitch, with
the ability to comment on the Twitch chat during playback. The videos
will make it onto YouTube. In my evening, I plan on organizing an online
drink and chat on Jitsi.
* Date: 5th August 2020
* Time: 13:00 CEST - https://time.is/en/CEST
* Talk: https://www.twitch.tv/TwitchPlaysCommonLisp
* Hangout: https://chat.heisig.xyz/TwitchPlaysCommonLisp @ 19:00 CEST
Massive thanks to Marco Heisig for providing the Jitsi instance where we
can hang out after the talk. (This time I've actually put in an hour for
that! That's a part of success.)
A mailing list has been created for the purpose of organizing and
promoting the online talks. Further announcements will be posted there.
See https://mailman.common-lisp.net/listinfo/online-lisp-meets
If you'd like to submit something yourself, please feel free to. The
slots are almost always open - there's no real queue for these videos.
BR and see you!
Michał "phoe" Herda
Good morning, everyone!
We officially start running out of fingers on a single hand, because
this Online Lisp Meeting shall be the fifth one.
We will have a pair of speakers this time: Bonface Munyoki, a software
developer with a keen interest in functional programming, and Robert
Strandh of SICL fame.
Bonface will talk about Guix Past:
> In the field of software development, libraries and tools evolve quickly
> to keep up with trends, improvements in hardware or to work around
> discovered/ exposed vulnerabilities. People, across diverse fields,
> adapt their work by updating the libraries they use to keep up. For
> scientists, that normally does not happen. Rarely will people maintain
> the code they wrote for a paper they published; instead, it's the
> impetus of the reader to reproduce the code based off the paper they
> read. Outside academic papers, for long-living projects like
> genenetwork¹, it would be desirable to provide a "time-machine" that
> enables the user to jump between various past versions. Guix past³ is a
> project initiated by Guix-HPC² that aims to provide these old, sometimes
> archived libraries to users with the goal of enabling people to
> reproduce old builds of software they used a couple of years ago.
>
> ¹ https://en.wikipedia.org/wiki/GeneNetwork
> ² https://hpc.guix.info/
> ³ https://gitlab.inria.fr/guix-hpc/guix-past
Robert will continue talking about creating a Common Lisp implementation
with part 2 of his talk.
> In this series of presentations, we examine different strategies for
> creating a Common Lisp implementation, as well as the pros and cons of
> each strategy.
>
> We assume basic knowledge about how a typical modern operating system
> (such as Unix) works, and how traditional batch languages (such as C)
> are compiled and executed on such a system. We furthermore assume
> medium-level knowledge about Common Lisp.
>
> In part 2, we sketch a possible compiler that generates byte codes,
> and an abstract machine for interpreting such byte codes.
As before, the talk will be pre-recorded and played back on Twitch, with
the ability to comment on the Twitch chat during playback. The videos
will make it onto YouTube. In my evening, I plan on organizing an online
drink and chat on Jitsi (I know that I promised you that the last time
and didn't deliver - I wholeheartedly apologize.) - let's discuss that
on #lispcafe.
Date/time/location:
* Date: 22nd July 2020
* Time: 13:00 CEST - https://time.is/en/CEST
* Talk: https://www.twitch.tv/TwitchPlaysCommonLisp
* Hangout: https://chat.heisig.xyz/TwitchPlaysCommonLisp
Massive thanks to Marco Heisig for providing the Jitsi instance where we
can hang out after the talk. (Ha! No one noticed that I called him Macro
in the previous mail. Strangely suitable, anyway.)
A mailing list has been created for the purpose of organizing and
promoting the online talks. Further announcements will be posted there.
See https://mailman.common-lisp.net/listinfo/online-lisp-meets
If you'd like to submit something yourself, please feel free to. The
slots are almost always open - there's no real queue for these videos.
BR and see you!
Michał "phoe" Herda
Good morning, everyone! It's time to have an Online Lisp Meeting for the
fourth time.
Robert Strandh will once again talk, this time about creating Common
Lisp implementations!
> In this series of presentations, we examine different strategies for
creating a Common Lisp implementation, as well as the pros and cons of
each strategy.
>
> We assume basic knowledge about how a typical modern operating system
(such as Unix) works, and how traditional batch languages (such as C)
are compiled and executed on such a system. We furthermore assume
medium-level knowledge about Common Lisp.
>
> In part 1, we compare the issues of creating a Common Lisp
implementation to the issues of writing a compiler for a traditional
batch language for a typical modern operating system. Given these
issues, we investigate some strategies for creating a compiler for a
Common Lisp system, and we examine the requirements on the run-time
environment for the compiled code to be executable in that environment.
As before, the talk will be pre-recorded and played back on Twitch, with
the ability to comment on the Twitch chat during playback. The videos
will make it onto YouTube. In my evening, I plan on organizing an online
drink and chat on Jitsi - let's discuss that on #lispcafe.
Date/time/location:
* Date: 29th June 2020
* Time: 13:00 CEST - https://time.is/en/CEST
* Talk: https://www.twitch.tv/TwitchPlaysCommonLisp
* Hangout: https://chat.heisig.xyz/TwitchPlaysCommonLisp
Massive thanks to Macro Heisig for providing the Jitsi instance where we
can hang out after the talk.
A mailing list has been created for the purpose of organizing and
promoting the online talks. Further announcements will be posted there.
See https://mailman.common-lisp.net/listinfo/online-lisp-meets
(I really think that I should customize the part where I ask everyone to
submit their own talks or Lispy things they'd like to share, so, I guess
that's what I am doing right now. Please throw them at me and I'll be
happy to host them!)
BR and see you!
Michał "phoe" Herda
Good morning, everyone! I am pleased to announce the third Online Lisp
Meeting.
There are two speakers for the third Online Lisp Meeting: Mark Evenson,
the current maintainer of Armed Bear Common Lisp, and Robert Strandh,
the initiator of SICL, the upcoming modular implementation of Common Lisp.
Mark Evenson will talk about "Reflections on the Future History of
Arming Bears".
> With the recent releases of Armed Bear Common Lisp over the past six
> months, the future of extending the implementation has come into
> sharper focus. The majority of this work has occurred within the head
> of one individual with little chance for public review and reflection,
> we believe that an externalized exposition of the reasoning behind
> these efforts would be of interest to those interested in the future
> history of Common Lisp implementations.
>
> Most notably, with abcl-1.6.0 we extended the set of underlying Java
> Virtual Machines (JVM) that the implementation runs on to include
> openjdk11 and openjdk14 while maintaining compatibilty with openjdk6.
> And with the internal overhaul or arrays specialized on unsigned bytes
> in abcl-1.7.0, we made it possible to share such byte vectors with
> memory allocated outside of the hosting JVM via system interfaces such
> as malloc(). We first present the goals and challenges in affecting
> these changes within the ABCL codebase. Then, we use this initial
> exposition to serve as a springboard to discuss outstanding needed
> changes in the ABCL 1 branch, and to outline some of the features
> intended to be present in ABCL 2, due to be released in the Fall of 2020.
>
Robert Strandh will talk about First-Class Global Environments in Common
Lisp.
> At the European Lisp Symposium in 2015, we presented a paper entitled
> "First-class Global Environments in Common Lisp". There are several
> possible use cases for such environments. In this presentation, we
> investigate the use of such environments at run time for so-called
> "sandboxing", i.e., to allow only a pre-selected set of
> functionalities to be visible to application code. In particular, we
> demonstrate the main idea that allows such environments to be used
> with no performance loss in almost all cases.
As before, the talk will be pre-recorded and played back on Twitch, with
the ability to comment on the Twitch chat during playback. Afterwards,
we will have an online drink and chat on Jitsi. The videos will then
make it onto YouTube.
Date/time/location:
* Date: 15th June 2020
* Time: 13:00 CEST - https://time.is/en/CEST
* Talk: https://www.twitch.tv/TwitchPlaysCommonLisp
* Hangout: https://chat.heisig.xyz/TwitchPlaysCommonLisp
Massive thanks to Marco Heisig for providing the Jitsi instance where we
can hang out after the talk.
A mailing list has been created for the purpose of organizing and
promoting the online talks. Further announcements will be posted there.
See https://mailman.common-lisp.net/listinfo/online-lisp-meets
Everyone, please feel free and welcome to suggest your own ideas and
record something that you'd like to talk about and share - along with
times and dates when I should play them.
BR and see you!
Michał "phoe" Herda
Good news, everyone! It is time to announce the second Online Lisp Meeting.
This time, the speaker will be Michael Raskin of
[`agnostic-lizard`](https://gitlab.common-lisp.net/mraskin/agnostic-lizard)
fame; he will talk about **Query-FS: Integrating with UNIX from Common
Lisp via FS API**.
> The talk is about Query-FS, a virtual filesystem representing various
queries (for example, SQL queries to a database) as directories. There
will be a demo of what basic usage looks like, and an explanation of how
it works inside.
> Warning: while Query-FS is implemented is Common Lisp, its goal is
integrating with non-Lisp things across a POSIX-defined interface. It
probably makes little sense in an environment integrated around a single
program (such as Emacs). And some included DSLs even look vaguely
similar to Bash. So, it is a tool in Common Lisp for non-Lispy use.
As before, the talk will be pre-recorded and played back on Twitch, with
the ability to comment on the Twitch chat during playback. Afterwards,
we will have an online drink and chat on Jitsi.
Date/time/location:
* Date: 1st June 2020
* Time: 13:00 CEST - https://time.is/en/CEST
* Talk: https://www.twitch.tv/TwitchPlaysCommonLisp
* Hangout: https://chat.heisig.xyz/TwitchPlaysCommonLisp
* Slides: https://gitlab.common-lisp.net/cl-fuse/query-fs/-/wikis/Main-page
Massive thanks to Marco Heisig for providing the Jitsi instance where we
can hang out after the talk.
A mailing list has been created for the purpose of organizing and
promoting the online talks. Further announcements will be posted there.
See https://mailman.common-lisp.net/listinfo/online-lisp-meets
Everyone, please feel free and welcome to suggest your own ideas and
record something that you'd like to talk about and share - along with
times and dates when I should play them.
BR and see you - Michał "phoe" Herda
Hello!
First and foremost, massive thanks to all the organizers, all the
speakers, and all the participants of European Lisp Symposium 2020 - the
first and greatest fully online edition of the conference, surprisingly
nice and wonderful in its own unique way. The recordings are available
at https://www.twitch.tv/elsconf/videos
Since the new formula turned out to be good and we are still likely
going to be stuck in homes for the forthcoming weeks, I have decided to
start a more cyclic Lisp meeting that is smaller in programme but more
frequent in time, so we have more chances to meet and hang out with
members of our Lisp community - even if just via chat and webcams.
Similar to the ELS, the talk will be pre-recorded and streamed on Twitch
with live chat available during the talk. Then, everyone is invited to
participate in an online discussion and after-party on Jitsi with
webcams and microphones. We can hang out, chat, comment, gossip, have a
virtual drink, and make some plans for the next meetings.
I can bootstrap the series. I will talk about multiple independent
condition systems in a single Common Lisp image. I will use an example
where I want to integrate two distinct condition/restart systems under
one debugger: a host one provided by the Lisp implementation, and an
independent and portable condition system.
Date/time/location:
* Date: 12th May 2020
* Time: 18:00 CEST - https://time.is/en/CEST
* Talk: https://www.twitch.tv/TwitchPlaysCommonLisp
* Hangout: https://chat.heisig.xyz/TwitchPlaysCommonLisp
Massive thanks to Marco Heisig for providing the Jitsi instance where we
can hang out after the talk.
A new mailing list has been created for the purpose of organizing and
promoting the online talks. Further announcements will be posted there.
See https://mailman.common-lisp.net/listinfo/online-lisp-meets
Everyone, please feel free and welcome to suggest your own ideas and
record something that you'd like to talk about and share.
BR and see you,
Michał "phoe" Herda