• ANN: Dogelog Player 1.1.5 (HTTP Server)

    From Mild Shock@21:1/5 to All on Sun Jan 21 16:57:21 2024
    Dear All,

    We are happy to announce a new edition of the
    Dogelog player:

    - Enhanced library(misc/markup):
    The library(misc/markup) has been extended to
    include a unified DOM writer abstraction. It can
    write to the GUI DOM in the browser, and it is also
    possible to write the DOM serialized in XML to a
    file. There are a variety of use cases for the
    library, e.g. creating static HTML pages.

    - New library(misc/vector):
    In this library we have brought together everything
    related to SVG that was previously scattered in
    the libraries library(misc/markup) and library(misc/react).
    The new advantages of the extended library (misc/markup)
    can also be used here, so the creation of static
    SVG pages is now supported.

    - New library(util/spin):
    The library provides a unified HTTP server
    abstraction. There are concrete implementations
    for nodeJS using node:http, for PyPy using http_server
    and for JDK 21 using Tomcat embedded. Local browser
    GET of 50,000 bytes via Prolog atom text lines
    enumeration requires approx. 5-10 ms for all Dogelog
    Player targets.

    Have Fun!
    Jan Burse, 21.01.2024, http://www.xlog.ch/

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mild Shock@21:1/5 to Mild Shock on Tue Jan 23 11:59:05 2024
    Quick update. This is fun we switched the implementation
    of library(util/spin) in Dogelog Player for Java from Tomcat 11
    embedded to this thingy here:

    Module jdk.httpserver - Package com.sun.net.httpserver https://download.java.net/java/early_access/panama/docs/api/jdk.httpserver/com/sun/net/httpserver/package-summary.html

    JEP 408: Simple Web Server
    https://openjdk.org/jeps/408

    Works fine so far and seems to be an itch speedier. Its
    already available in our current devel version 1.1.6 of
    Dogelog Player for Java via our GIT.

    Mild Shock schrieb:
    Dear All,

    We are happy to announce a new edition of the
    Dogelog player:

    - Enhanced library(misc/markup):
      The library(misc/markup) has been extended to
    include a unified DOM writer abstraction. It can
    write to the GUI DOM in the browser, and it is also
    possible to write the DOM serialized in XML to a
    file. There are a variety of use cases for the
    library, e.g. creating static HTML pages.

    - New library(misc/vector):
      In this library we have brought together everything
    related to SVG that was previously scattered in
    the libraries library(misc/markup) and library(misc/react).
    The new advantages of the extended library (misc/markup)
    can also be used here, so the creation of static
    SVG pages is now supported.

    - New library(util/spin):
      The library provides a unified HTTP server
    abstraction.  There are concrete implementations
    for nodeJS using node:http, for PyPy using http_server
    and for JDK 21 using Tomcat embedded.  Local browser
    GET of 50,000 bytes via Prolog atom text lines
    enumeration requires approx. 5-10 ms for all Dogelog
    Player targets.

    Have Fun!
    Jan Burse, 21.01.2024, http://www.xlog.ch/

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mild Shock@21:1/5 to Mild Shock on Wed Jan 24 10:51:57 2024
    We describe the implementation of a dynamical HTML
    page in Prolog that displays the moon phase seen from
    the northern hemisphere for a given day. The code
    demonstrates a HTTP server addition to Dogelog Player,
    a Prolog system 100% written in Prolog itself available
    for the platforms JavaScript, Python and Java.

    We spent one morning to create a dynamical HTML page,
    that shows the moon phase of a day via SVG. The coding
    is similar to how one is usually dealing with a TTY,
    lowering the learning curve. The single Prolog text
    can be used to serve the HTML page unchanged via
    JavaScript, Python or Java.

    See also:

    Moon Server with Dogelog Player https://twitter.com/dogelogch/status/1749847817579827503

    Moon Server with Dogelog Player
    https://www.facebook.com/groups/dogelog

    Mild Shock schrieb:

    Quick update. This is fun we switched the implementation
    of library(util/spin) in Dogelog Player for Java from Tomcat 11
    embedded to this thingy here:

    Module jdk.httpserver - Package com.sun.net.httpserver https://download.java.net/java/early_access/panama/docs/api/jdk.httpserver/com/sun/net/httpserver/package-summary.html


    JEP 408: Simple Web Server
    https://openjdk.org/jeps/408

    Works fine so far and seems to be an itch speedier. Its
    already available in our current devel version 1.1.6 of
    Dogelog Player for Java via our GIT.

    Mild Shock schrieb:
    Dear All,

    We are happy to announce a new edition of the
    Dogelog player:

    - Enhanced library(misc/markup):
       The library(misc/markup) has been extended to
    include a unified DOM writer abstraction. It can
    write to the GUI DOM in the browser, and it is also
    possible to write the DOM serialized in XML to a
    file. There are a variety of use cases for the
    library, e.g. creating static HTML pages.

    - New library(misc/vector):
       In this library we have brought together everything
    related to SVG that was previously scattered in
    the libraries library(misc/markup) and library(misc/react).
    The new advantages of the extended library (misc/markup)
    can also be used here, so the creation of static
    SVG pages is now supported.

    - New library(util/spin):
       The library provides a unified HTTP server
    abstraction.  There are concrete implementations
    for nodeJS using node:http, for PyPy using http_server
    and for JDK 21 using Tomcat embedded.  Local browser
    GET of 50,000 bytes via Prolog atom text lines
    enumeration requires approx. 5-10 ms for all Dogelog
    Player targets.

    Have Fun!
    Jan Burse, 21.01.2024, http://www.xlog.ch/


    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mild Shock@21:1/5 to Mild Shock on Fri Feb 2 11:34:53 2024
    Dogelog Player is a Prolog system that was
    conceived to run on coroutine capable targets
    if a target can implement the instruction ‘$YIELD’/1.
    So far this was realized for JavaScript and Python
    including a notion of tasks. We enhanced the
    instruction and do now provide async I/O.

    We now invoke first a promise factory and then
    call the ‘$YIELD’/1 instruction. We might equally
    well rename it into a ‘$AWAIT’/1 instruction. We
    then use our new library(spin) and demonstrate
    running multiple HTTP servers in our single
    threaded Dogelog Player.

    See also:

    Async I/O in Dogelog Player https://twitter.com/dogelogch/status/1753364266017566812

    Async I/O in Dogelog Player
    https://www.facebook.com/groups/dogelog


    Mild Shock schrieb:

    We describe the implementation of a dynamical HTML
    page in Prolog that displays the moon phase seen from
    the northern hemisphere for a given day. The code
    demonstrates a HTTP server addition to Dogelog Player,
    a Prolog system 100% written in Prolog itself available
    for the platforms JavaScript, Python and Java.

    We spent one morning to create a dynamical HTML page,
    that shows the moon phase of a day via SVG. The coding
    is similar to how one is usually dealing with a TTY,
    lowering the learning curve. The single Prolog text
    can be used to serve the HTML page unchanged via
    JavaScript, Python or Java.

    See also:

    Moon Server with Dogelog Player https://twitter.com/dogelogch/status/1749847817579827503

    Moon Server with Dogelog Player
    https://www.facebook.com/groups/dogelog

    Mild Shock schrieb:

    Quick update. This is fun we switched the implementation
    of library(util/spin) in Dogelog Player for Java from Tomcat 11
    embedded to this thingy here:

    Module jdk.httpserver - Package com.sun.net.httpserver
    https://download.java.net/java/early_access/panama/docs/api/jdk.httpserver/com/sun/net/httpserver/package-summary.html


    JEP 408: Simple Web Server
    https://openjdk.org/jeps/408

    Works fine so far and seems to be an itch speedier. Its
    already available in our current devel version 1.1.6 of
    Dogelog Player for Java via our GIT.

    Mild Shock schrieb:
    Dear All,

    We are happy to announce a new edition of the
    Dogelog player:

    - Enhanced library(misc/markup):
       The library(misc/markup) has been extended to
    include a unified DOM writer abstraction. It can
    write to the GUI DOM in the browser, and it is also
    possible to write the DOM serialized in XML to a
    file. There are a variety of use cases for the
    library, e.g. creating static HTML pages.

    - New library(misc/vector):
       In this library we have brought together everything
    related to SVG that was previously scattered in
    the libraries library(misc/markup) and library(misc/react).
    The new advantages of the extended library (misc/markup)
    can also be used here, so the creation of static
    SVG pages is now supported.

    - New library(util/spin):
       The library provides a unified HTTP server
    abstraction.  There are concrete implementations
    for nodeJS using node:http, for PyPy using http_server
    and for JDK 21 using Tomcat embedded.  Local browser
    GET of 50,000 bytes via Prolog atom text lines
    enumeration requires approx. 5-10 ms for all Dogelog
    Player targets.

    Have Fun!
    Jan Burse, 21.01.2024, http://www.xlog.ch/



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mild Shock@21:1/5 to All on Sat Feb 10 03:41:01 2024
    We already reported the new capability
    that we can read async from streams. We made
    this available for the file system reads on
    nodeJS. We report here about a further progress
    extending the async approach to HTTP fetch in
    the browser and on nodeJS.

    Multiple downloads make a case for async I/O
    since RFC 2616 limits the number of connections.
    HTTP/2 allows to send off multiple requests
    which async I/O can capitalize. We demonstrate
    quasi-parallel execution in Dogelog Player for
    both the browser and nodeJS.

    See also:

    Async HTTP Client for Dogelog Player https://twitter.com/dogelogch/status/1756144112946807135

    Async HTTP Client for Dogelog Player
    https://www.facebook.com/groups/dogelog

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mild Shock@21:1/5 to Mild Shock on Tue Feb 20 17:09:53 2024
    Dogelog Player is a Prolog system that features a
    ‘$YIELD’/1 instruction. The instruction was conceived
    for single threaded runtimes with an event loop. We
    could now demonstrate how to realize it without
    an explicit event loop in a multi threaded runtime.

    The idea is that threads use a bouncer semaphore
    to get a permission to execute and thus become
    “coroutines”. Now that we have layed the foundation
    we started asyncifying Dogelog Player for Java.
    We demonstrate a HTTP server and HTTP client
    interaction in the same JVM.

    See also:

    Surrogate Async/Await with JDK 21 https://twitter.com/dogelogch/status/1759972607355470296

    Surrogate Async/Await with JDK 21
    https://www.facebook.com/groups/dogelog

    Mild Shock schrieb:

    We already reported the new capability
    that we can read async from streams. We made
    this available for the file system reads on
    nodeJS. We report here about a further progress
    extending the async approach to HTTP fetch in
    the browser and on nodeJS.

    Multiple downloads make a case for async I/O
    since RFC 2616 limits the number of connections.
    HTTP/2 allows to send off multiple requests
    which async I/O can capitalize. We demonstrate
    quasi-parallel execution in Dogelog Player for
    both the browser and nodeJS.

    See also:

    Async HTTP Client for Dogelog Player https://twitter.com/dogelogch/status/1756144112946807135

    Async HTTP Client for Dogelog Player
    https://www.facebook.com/groups/dogelog

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Lawrence D'Oliveiro@21:1/5 to Mild Shock on Tue Feb 20 19:41:10 2024
    On Tue, 20 Feb 2024 17:09:53 +0100, Mild Shock wrote:

    The idea is that threads use a bouncer semaphore to get a permission to execute and thus become “coroutines”.

    But they are still stackful coroutines, not stackless.

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mild Shock@21:1/5 to Mild Shock on Wed Feb 21 00:56:55 2024
    Basically you can programm in so called "DIRECT STYLE"
    even if async I/O is involved, which might be even a
    shock for functional programming language users

    that are used to a lot of nonsense.

    See also:

    Async/Await for the Monadic Programmer https://www.youtube.com/watch?v=OH5cxLNTTPo

    DIRECT STYLE SCALA Scalar Conference 2023 https://www.youtube.com/watch?v=0Fm0y4K4YO8

    Mild Shock schrieb:

    Well they have suspend/resume semantics. They
    are not continuations. They aim is to provide
    async/await and not only setTimeout().

    As a result you don't need to write libraries
    with a continuation parameters. This is very unlike
    nonsense such as the express web framework.

    stackfulness
    In contrast to a stackless coroutine a stackful
    coroutine can be suspended from within a nested
    stackframe. Execution resumes at exactly the same
    point in the code where it was suspended before.

    stackless
    With a stackless coroutine, only the top-level routine
    may be suspended. Any routine called by that top-level
    routine may not itself suspend. This prohibits
    providing suspend/resume operations in routines within
    a general-purpose library. https://www.boost.org/doc/libs/1_57_0/libs/coroutine/doc/html/coroutine/intro.html#coroutine.intro.stackfulness



    Lawrence D'Oliveiro schrieb:
    On Tue, 20 Feb 2024 17:09:53 +0100, Mild Shock wrote:

    The idea is that threads use a bouncer semaphore to get a permission to
    execute and thus become “coroutines”.

    But they are still stackful coroutines, not stackless.



    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mild Shock@21:1/5 to Lawrence D'Oliveiro on Wed Feb 21 00:54:52 2024
    Well they have suspend/resume semantics. They
    are not continuations. They aim is to provide
    async/await and not only setTimeout().

    As a result you don't need to write libraries
    with a continuation parameters. This is very unlike
    nonsense such as the express web framework.

    stackfulness
    In contrast to a stackless coroutine a stackful
    coroutine can be suspended from within a nested
    stackframe. Execution resumes at exactly the same
    point in the code where it was suspended before.

    stackless
    With a stackless coroutine, only the top-level routine
    may be suspended. Any routine called by that top-level
    routine may not itself suspend. This prohibits
    providing suspend/resume operations in routines within
    a general-purpose library. https://www.boost.org/doc/libs/1_57_0/libs/coroutine/doc/html/coroutine/intro.html#coroutine.intro.stackfulness


    Lawrence D'Oliveiro schrieb:
    On Tue, 20 Feb 2024 17:09:53 +0100, Mild Shock wrote:

    The idea is that threads use a bouncer semaphore to get a permission to
    execute and thus become “coroutines”.

    But they are still stackful coroutines, not stackless.


    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mild Shock@21:1/5 to Mild Shock on Wed Feb 21 01:13:33 2024
    Its also proof of concept that no stack copying
    is necessary. Well its not 100% true the Prolog
    interpreter does a little bit unwind and rewind

    during the '$YIELD'/1 instruction. But we do
    nowhere copy some native stack, this is unlike
    Martin Odersky's speculation, he might implement

    someting with stack copying. Except that a virtual
    threads might using a copying when they resize
    their stack, I don't see any need for copying.

    Also sometimes a callback can be piggy packed on
    an existing coroutine if it doesn't yield itself,
    I am already using this in Dogelog Player as an

    optimization. The idea to use semaphores in my
    implementation can be credited to this paper
    from 1980 where semaphores are the main switchpoint:

    Extension of Pascal and its Application to
    Quasi-Parallel Programming and Simulation, Software -
    Practice and Experience, 10 (1980), 773-789
    J. Kriz and H. Sandmayr
    https://www.academia.edu/47139332

    But my experience with JDK 21 virtual threads
    is still poor, I am only beginning to explore them
    as a way to have a large number of coroutines.

    Mild Shock schrieb:

    Basically you can programm in so called "DIRECT STYLE"
    even if async I/O is involved, which might be even a
    shock for functional programming language users

    that are used to a lot of nonsense.

    See also:

    Async/Await for the Monadic Programmer https://www.youtube.com/watch?v=OH5cxLNTTPo

    DIRECT STYLE SCALA Scalar Conference 2023 https://www.youtube.com/watch?v=0Fm0y4K4YO8

    Mild Shock schrieb:

    Well they have suspend/resume semantics. They
    are not continuations. They aim is to provide
    async/await and not only setTimeout().

    As a result you don't need to write libraries
    with a continuation parameters. This is very unlike
    nonsense such as the express web framework.

    stackfulness
    In contrast to a stackless coroutine a stackful
    coroutine can be suspended from within a nested
    stackframe. Execution resumes at exactly the same
    point in the code where it was suspended before.

    stackless
    With a stackless coroutine, only the top-level routine
    may be suspended. Any routine called by that top-level
    routine may not itself suspend. This prohibits
    providing suspend/resume operations in routines within
    a general-purpose library.
    https://www.boost.org/doc/libs/1_57_0/libs/coroutine/doc/html/coroutine/intro.html#coroutine.intro.stackfulness



    Lawrence D'Oliveiro schrieb:
    On Tue, 20 Feb 2024 17:09:53 +0100, Mild Shock wrote:

    The idea is that threads use a bouncer semaphore to get a permission to >>>> execute and thus become “coroutines”.

    But they are still stackful coroutines, not stackless.




    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mild Shock@21:1/5 to Lawrence D'Oliveiro on Wed Feb 21 13:37:51 2024
    Thanks for asking. I made the Prolog system
    source code docu a little bit clearer now:

    From the JavaScript file "machine.mjs":

    /**
    * Run a callback once, i.e. no choice point or trailing left
    * behind. Callbacks are run with auto-yield disabled and
    * promises are not accepted, i.e. run "stackless" on top of the
    * given main stack or side stack. "stackless" because completion,
    * i.e. return or exception by the callback, is the only context switch.
    */
    export function launch(form, buf, params);

    /**
    * Run a task once, i.e. no choice point or trailing left
    * behind. Tasks are run with auto-yield enabled and promises are
    * accepted, i.e. run "stackfull" on top of the given main stack
    * or side stack. "stackfull" because not only completion, i.e.
    * return or exception by the task, cause a context switch, but
    * also await of an auto-yield or promise.
    */
    export async function launch_async(form, buf, params);

    You find this in the Dogelog Player GIT.

    Lawrence D'Oliveiro schrieb:
    On Tue, 20 Feb 2024 17:09:53 +0100, Mild Shock wrote:

    The idea is that threads use a bouncer semaphore to get a permission to
    execute and thus become “coroutines”.

    But they are still stackful coroutines, not stackless.


    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)
  • From Mild Shock@21:1/5 to All on Sun Mar 3 20:26:38 2024
    Dogelog Player was born in 2021 after heated internet
    discussions. Its a project of an async Prolog system,
    that can be used for backend server development or
    inside a web browser client. Currently Dogelog Player
    is fully open source and gets the most care by
    its founding company.


    A couple of Prolog systems provide sponsor buttons,
    mainly powered by GitHub. On the other hand Crypto
    wallets projections indicating exponential growth.
    We setup a donation page, based on Solana, which is
    deemed highly energy efficient, minimizing its
    global carbon footprint.

    See also:

    Sustainable Appreciation for Dogelog Player https://twitter.com/dogelogch/status/1764369222270927180

    Sustainable Appreciation for Dogelog Player https://www.facebook.com/groups/dogelog

    --- SoupGate-Win32 v1.05
    * Origin: fsxNet Usenet Gateway (21:1/5)