ChifiSource / Olive.jl

pure julia notebooks
MIT License
152 stars 6 forks source link

Feedback and question #134

Closed PallHaraldsson closed 8 months ago

PallHaraldsson commented 8 months ago

Hi,

It's great to see your project finally registered and I also noticed your new Gattino plotting. I can't understand how productive you are.

A. Your doc could mention R (and Python) more prominently, since I see it supported too: "Here is an example from OlivePy, the python Cell"

I'm looking forward to trying out your project more, it seems to simply just work, after a (one-time, I guess) small delay.

Since this is a Julia project, Python users would need to set it up. I'm a Julia user first, and unlike Pluto which (kind of) Julia only, I think it's great you support more. I'm thinking it might draw in more Python and R users; to call Julia, reuse both ways. Possibly a really good setup for them could be done with a python package using JuliaCall from PythonCall.jl, at least when the protect more polished.

I'm curious, did you reuse much of Pluto (or its dependencies), since I can't see that done? Do you support importing all Pluto files, since they are plain Julia code? They have features that are based on JavaScript, so I'm not sure, maybe all of their features on from Jupyther just work?

I've seen people argue against (Python) notebooks, for some reasons, mostly that I recall, not being reactive, or reasons not applying to Pluto nor your project, except maybe if importing.

A. There were slight editing/cursor and display issues:

A = [1 2;3 4] 2×2 Matrix{Int64}: 1 2 3 4

A^2.1 2×2 Matrix{ComplexF64}: 8.24768+0.02953im 11.8464-0.0135078im 17.7695-0.0202617im 26.0172+0.00926826im

[I could copy paste if highlighting from the result up, but strangly not if highlighting my code A, and "down" if you understand.]

I meant to type, ^2 and did, but sometimes ² which I could do with the keyboard (by accident, with same keys on my Icelandic keyboard), and it does display, but see concole error in C. on it.

B. When using first there was a slight wait, I thought frozen explained by:

 ◓ olive
  ✗ olive
  0 dependencies successfully precompiled in 2 seconds. 3 already precompiled.
  1 dependency errored. To see a full report either run `import Pkg; Pkg.precompile()` or load the package
     Cloning git-repo `https://github.com/ChifiSource/Olive.jl`
  0 dependencies successfully precompiled in 3 seconds. 3 already precompiled.
  1 dependency errored. To see a full report either run `import Pkg; Pkg.precompile()` or load the package

[that error seemingly didn't stop me, at least not yet.]

Fetching: [========>                                ]  19.7 %
┌ Error: handle_connection handler error.               ]  22.5 %
│ 
│ ===========================
│ HTTP Error message:
│ 
│ ERROR: invalid git HEAD (reference 'refs/heads/master' not found)
│ Stacktrace:
│   [1] pkgerror(msg::String)
│     @ Pkg.Types ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/Types.jl:69
│   [2] check_valid_HEAD(repo::LibGit2.GitRepo)
│     @ Pkg.GitTools ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/GitTools.jl:332
│   [3] (::Pkg.Types.var"#57#58"{Pkg.Types.Context, Pkg.Types.PackageSpec, String})(repo::LibGit2.GitRepo)
│     @ Pkg.Types ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/Types.jl:754
│   [4] with(f::Pkg.Types.var"#57#58"{Pkg.Types.Context, Pkg.Types.PackageSpec, String}, obj::LibGit2.GitRepo)
│     @ LibGit2 ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/LibGit2/src/types.jl:1160
│   [5] handle_repo_add!(ctx::Pkg.Types.Context, pkg::Pkg.Types.PackageSpec)
│     @ Pkg.Types ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/Types.jl:752
│   [6] handle_repos_add!(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec})
│     @ Pkg.Types ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/Types.jl:822
│   [7] add(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec}; preserve::Pkg.Types.PreserveLevel, platform::Base.BinaryPlatforms.Platform, kwargs::Base.Pairs{Symbol, Base.TTY, Tuple{Symbol}, NamedTuple{(:io,), Tuple{Base.TTY}}})
│     @ Pkg.API ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:255
│   [8] add(pkgs::Vector{Pkg.Types.PackageSpec}; io::Base.TTY, kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
│     @ Pkg.API ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:156
│   [9] add(pkgs::Vector{Pkg.Types.PackageSpec})
│     @ Pkg.API ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:145
│  [10] #add#24
│     @ ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:143 [inlined]
│  [11] add
│     @ ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:143 [inlined]
│  [12] add(; name::Nothing, uuid::Nothing, version::Nothing, url::String, rev::Nothing, path::Nothing, mode::Pkg.Types.PackageMode, subdir::Nothing, kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
│     @ Pkg.API ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:173
│  [13] add
│     @ ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:162 [inlined]
│  [14] (::Olive.var"#435#449"{ToolipsSession.ComponentModifier, Toolips.Component{:progress}, Toolips.Component{:a}, String, Toolips.Connection, Toolips.Component{:div}})(cm3::ToolipsSession.ComponentModifier)
│     @ Olive ~/.julia/packages/Olive/rxQ3t/src/Olive.jl:345
│  [15] document_linker(c::Toolips.Connection)
│     @ ToolipsSession ~/.julia/packages/ToolipsSession/CRfXW/src/ToolipsSession.jl:94
│  [16] (::Toolips.var"#serve#63"{Vector{Toolips.AbstractRoute}, String, Vector{Toolips.ServerExtension}, Vector{Toolips.ServerExtension}})(http::HTTP.Streams.Stream{HTTP.Messages.Request, HTTP.Connections.Connection{Sockets.TCPSocket}})
│     @ Toolips ~/.julia/packages/Toolips/WjEbl/src/server/Core.jl:1413
│  [17] #invokelatest#2
│     @ ./essentials.jl:819 [inlined]
│  [18] invokelatest
│     @ ./essentials.jl:816 [inlined]
│  [19] handle_connection(f::Function, c::HTTP.Connections.Connection{Sockets.TCPSocket}, listener::HTTP.Servers.Listener{Nothing, Sockets.TCPServer}, readtimeout::Int64, access_log::Nothing)
│     @ HTTP.Servers ~/.julia/packages/HTTP/SN7VW/src/Servers.jl:450
│  [20] macro expansion
│     @ ~/.julia/packages/HTTP/SN7VW/src/Servers.jl:386 [inlined]
│ 
│ caused by: GitError(Code:EUNBORNBRANCH, Class:Reference, reference 'refs/heads/master' not found)
│ Stacktrace:
│   [1] macro expansion
│     @ ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/LibGit2/src/error.jl:111 [inlined]
│   [2] head(repo::LibGit2.GitRepo)
│     @ LibGit2 ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/LibGit2/src/reference.jl:44
│   [3] check_valid_HEAD(repo::LibGit2.GitRepo)
│     @ Pkg.GitTools ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/GitTools.jl:330
│   [4] (::Pkg.Types.var"#57#58"{Pkg.Types.Context, Pkg.Types.PackageSpec, String})(repo::LibGit2.GitRepo)
│     @ Pkg.Types ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/Types.jl:754
│   [5] with(f::Pkg.Types.var"#57#58"{Pkg.Types.Context, Pkg.Types.PackageSpec, String}, obj::LibGit2.GitRepo)
│     @ LibGit2 ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/LibGit2/src/types.jl:1160
│   [6] handle_repo_add!(ctx::Pkg.Types.Context, pkg::Pkg.Types.PackageSpec)
│     @ Pkg.Types ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/Types.jl:752
│   [7] handle_repos_add!(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec})
│     @ Pkg.Types ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/Types.jl:822
│   [8] add(ctx::Pkg.Types.Context, pkgs::Vector{Pkg.Types.PackageSpec}; preserve::Pkg.Types.PreserveLevel, platform::Base.BinaryPlatforms.Platform, kwargs::Base.Pairs{Symbol, Base.TTY, Tuple{Symbol}, NamedTuple{(:io,), Tuple{Base.TTY}}})
│     @ Pkg.API ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:255
│   [9] add(pkgs::Vector{Pkg.Types.PackageSpec}; io::Base.TTY, kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
│     @ Pkg.API ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:156
│  [10] add(pkgs::Vector{Pkg.Types.PackageSpec})
│     @ Pkg.API ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:145
│  [11] #add#24
│     @ ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:143 [inlined]
│  [12] add
│     @ ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:143 [inlined]
│  [13] add(; name::Nothing, uuid::Nothing, version::Nothing, url::String, rev::Nothing, path::Nothing, mode::Pkg.Types.PackageMode, subdir::Nothing, kwargs::Base.Pairs{Symbol, Union{}, Tuple{}, NamedTuple{(), Tuple{}}})
│     @ Pkg.API ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:173
│  [14] add
│     @ ~/.julia/juliaup/julia-1.9.3+0.x64.linux.gnu/share/julia/stdlib/v1.9/Pkg/src/API.jl:162 [inlined]
│  [15] (::Olive.var"#435#449"{ToolipsSession.ComponentModifier, Toolips.Component{:progress}, Toolips.Component{:a}, String, Toolips.Connection, Toolips.Component{:div}})(cm3::ToolipsSession.ComponentModifier)
│     @ Olive ~/.julia/packages/Olive/rxQ3t/src/Olive.jl:345
│  [16] document_linker(c::Toolips.Connection)
│     @ ToolipsSession ~/.julia/packages/ToolipsSession/CRfXW/src/ToolipsSession.jl:94
│  [17] (::Toolips.var"#serve#63"{Vector{Toolips.AbstractRoute}, String, Vector{Toolips.ServerExtension}, Vector{Toolips.ServerExtension}})(http::HTTP.Streams.Stream{HTTP.Messages.Request, HTTP.Connections.Connection{Sockets.TCPSocket}})
│     @ Toolips ~/.julia/packages/Toolips/WjEbl/src/server/Core.jl:1413
│  [18] #invokelatest#2
│     @ ./essentials.jl:819 [inlined]
│  [19] invokelatest
│     @ ./essentials.jl:816 [inlined]
│  [20] handle_connection(f::Function, c::HTTP.Connections.Connection{Sockets.TCPSocket}, listener::HTTP.Servers.Listener{Nothing, Sockets.TCPServer}, readtimeout::Int64, access_log::Nothing)
│     @ HTTP.Servers ~/.julia/packages/HTTP/SN7VW/src/Servers.jl:450
│  [21] macro expansion
│     @ ~/.julia/packages/HTTP/SN7VW/src/Servers.jl:386 [inlined]
│  [22] (::HTTP.Servers.var"#16#17"{Toolips.var"#serve#63"{Vector{Toolips.AbstractRoute}, String, Vector{Toolips.ServerExtension}, Vector{Toolips.ServerExtension}}, HTTP.Servers.Listener{Nothing, Sockets.TCPServer}, Set{HTTP.Connections.Connection}, Int64, Nothing, Base.Semaphore, HTTP.Connections.Connection{Sockets.TCPSocket}})()
│     @ HTTP.Servers ./task.jl:514
└ @ HTTP.Servers ~/.julia/packages/HTTP/SN7VW/src/Servers.jl:465

C.

┌ Error: handle_connection handler error. 
│ 
│ ===========================
│ HTTP Error message:
│ 
│ ERROR: StringIndexError: invalid index [240022], valid nearby indices [240021]=>'²', [240023]=>'<'
│ Stacktrace:
│   [1] string_index_err(s::String, i::Int64)
│     @ Base ./strings/string.jl:12
│   [2] getindex
│     @ ./strings/string.jl:278 [inlined]
│   [3] #6
│     @ ~/.julia/packages/ToolipsSession/CRfXW/src/Modifier.jl:91 [inlined]
│   [4] (::ToolipsSession.var"#6#9"{String})(compname::String)
│     @ ToolipsSession ./none:0
│   [5] iterate
│     @ ./generator.jl:47 [inlined]
│   [6] collect_to!(dest::Vector{Toolips.Component{:div}}, itr::Base.Generator{Vector{String}, ToolipsSession.var"#6#9"{String}}, offs::Int64, st::Int64)
│     @ Base ./array.jl:840
│   [7] collect_to_with_first!(dest::Vector{Toolips.Component{:div}}, v1::Toolips.Component{:div}, itr::Base.Generator{Vector{String}, ToolipsSession.var"#6#9"{String}}, st::Int64)
│     @ Base ./array.jl:818
│   [8] collect(itr::Base.Generator{Vector{String}, ToolipsSession.var"#6#9"{String}})
│     @ Base ./array.jl:792
│   [9] htmlcomponent(s::String, readonly::Vector{String})
│     @ ToolipsSession ~/.julia/packages/ToolipsSession/CRfXW/src/Modifier.jl:83
│  [10] ComponentModifier
│     @ ~/.julia/packages/ToolipsSession/CRfXW/src/Modifier.jl:236 [inlined]
│  [11] document_linker(c::Toolips.Connection)
│     @ ToolipsSession ~/.julia/packages/ToolipsSession/CRfXW/src/ToolipsSession.jl:89
│  [12] (::Toolips.var"#serve#63"{Vector{Toolips.AbstractRoute}, String, Vector{Toolips.ServerExtension}, Vector{Toolips.ServerExtension}})(http::HTTP.Streams.Stream{HTTP.Messages.Request, HTTP.Connections.Connection{Sockets.TCPSocket}})
│     @ Toolips ~/.julia/packages/Toolips/WjEbl/src/server/Core.jl:1413
│  [13] #invokelatest#2
│     @ ./essentials.jl:819 [inlined]
│  [14] invokelatest
│     @ ./essentials.jl:816 [inlined]
│  [15] handle_connection(f::Function, c::HTTP.Connections.Connection{Sockets.TCPSocket}, listener::HTTP.Servers.Listener{Nothing, Sockets.TCPServer}, readtimeout::Int64, access_log::Nothing)
│     @ HTTP.Servers ~/.julia/packages/HTTP/SN7VW/src/Servers.jl:450
│  [16] macro expansion
│     @ ~/.julia/packages/HTTP/SN7VW/src/Servers.jl:386 [inlined]
│  [17] (::HTTP.Servers.var"#16#17"{Toolips.var"#serve#63"{Vector{Toolips.AbstractRoute}, String, Vector{Toolips.ServerExtension}, Vector{Toolips.ServerExtension}}, HTTP.Servers.Listener{Nothing, Sockets.TCPServer}, Set{HTTP.Connections.Connection}, Int64, Nothing, Base.Semaphore, HTTP.Connections.Connection{Sockets.TCPSocket}})()
│     @ HTTP.Servers ./task.jl:514
└ @ HTTP.Servers ~/.julia/packages/HTTP/SN7VW/src/Servers.jl:465
emmaccode commented 8 months ago

Thank you for kind words @PallHaraldsson , and your support for all this time.

A ( I )

This certainly would not be a bad idea -- I plan to expand this documentation (and rewrite some sections) into an eventual documentation that hosts Olive. The thing is that languages are added to Olive via an extension. OlivePy is cited as an example because this package is nearly done. And yelp, it ties the objects from all languages in together -- just as the tomlvalues cells do for data into Julia. There are just a few things left to do on that project, mainly some fixes for the ability to open .py files (rather than just using python in a .jl file) and updates to the syntax highlighter.

I did not use any Pluto tech-stack. Pluto files are not regular Julia files, though they do contain normal Julia code; they contain special characters which denote cells and a list of cells with their evaluation order at the top. Fortunately, IPyCells checks if a .jl file contains Pluto cells, Olive cells, or just regular Julia text -- so reading Pluto is in fact supported.

Writing to pluto... not so much.

A (II)

Hmm.. If I understand this correctly, you mean you are able to select from the end of the text but not the start? I will try to replicate the issue on my machine tomorrow. The error C seems to be coming from the fullstack parser -- I will look into making some updates to fix both of those. Thank you for bringing these to my attention :)

B

The line that this code comes from just does Pkg.add("Pkg"). This error might be some sort of fluke or something. I am not exactly sure how I could replicate this, or if solving such an issue falls into my hands. I will make sure to look into it a bit more before writing it off though.

Thanks for the issue and letting me know all of this, as well as the feedback ! Have a wonderful rest of your day 👍🏻

VarLad commented 8 months ago

@emmaccode I can replicate the same error!

On the other hand, one recommendation from my side:

Skip the initial setup

Like Pluto, it'd be better if all stuff related to Olive went (by default) into .julia/olive_notebooks folder, and within the notebook, we had the option to save the notebook somewhere else if we actually wanted to.

Have a home page:

I did not see a home page, but it would be nice if at the start we get a homepage which displays a list of:

Workspace oriented file inspector

Some other issues I encountered are:

  1. Misplaced cursor image
  2. Vanishing text image image
  3. Selection is awry (from the same screenshot)
  4. Not sure if its the same bug, but there's a lot of latency when typing... :sweat_smile:
VarLad commented 8 months ago

Thanks a lot for your efforts on this project. ^^

PallHaraldsson commented 8 months ago

I edited my comment to what I meant to say:

I've seen people argue against (Python) notebooks, for some reasons, mostly that I recall, not being reactive

I suppose most people in Python or R would just use what they are used to from their ecosystems, even if non-ideal, though there may exist some reactive notebooks there I do not know of. And Julia people would use Pluto (for reactivity), so it's unclear why they would use your project. Except for e.g. Python and R with. I'll look it over more, there are probably a not more features I'm overlooking.

I did not use any Pluto tech-stack. Pluto files are not regular Julia files, though they do contain normal Julia code; they contain special characters which denote cells

It's intriguing you wrote from scratch. It may be a pro and a con. I know of Pluto (and Neptune), though I don't use notebooks much. I've just tried a bit, and will see if I like yours better. Most users would want to know pros and cons of yours vs. other options, as users, but for you I would have thought helpful to reuse much code, less duplication, and then Pluto could even have reused your code.

emmaccode commented 8 months ago

I edited my comment to what I meant to say:

I've seen people argue against (Python) notebooks, for some reasons, mostly that I recall, not being reactive

I suppose most people in Python or R would just use what they are used to from their ecosystems, even if non-ideal, though there may exist some reactive notebooks there I do not know of. And Julia people would use Pluto (for reactivity), so it's unclear why they would use your project. Except for e.g. Python and R with. I'll look it over more, there are probably a not more features I'm overlooking.

I did not use any Pluto tech-stack. Pluto files are not regular Julia files, though they do contain normal Julia code; they contain special characters which denote cells

It's intriguing you wrote from scratch. It may be a pro and a con. I know of Pluto (and Neptune), though I don't use notebooks much. I've just tried a bit, and will see if I like yours better. Most users would want to know pros and cons of yours vs. other options, as users, but for you I would have thought helpful to reuse much code, less duplication, and then Pluto could even have reused your code.

I think you are missing a substantial part of the project -- this project is not just a notebook editor. Olive is an anything editor, which allows a reproducible Project, Cell, and Directory structure to be applied to any context with multiple dispatch. The central idea is that more features are added to the project using multiple dispatch. This is part of why the project is so challenging. Point being, Olive grants the ability to edit any file and export to any format, execute any type of code, syntax, or data language, or even be an image editor.

In the case of Pluto, we are comparing a green apple to a red apple -- yeah they are similar, but they do not taste the same. Pluto is a reactive notebook built for creating reproducible Julia code. Olive is an open-ended development notebook development environment centered around multiple dispatch. The base Olive just comes with extensions to program Julia. I even plan to eventually build things like visual-web-editors for Toolips into it -- whatever data Julia is able to transmit, Olive can work with. While Pluto is designed for one thing that it does really well, Olive is designed to make all of those capabilities optional and added with extensions. The extensions also plan to make Olive applicable to contexts where I think Pluto is less applicable, such as deployment or hosting documentation or notebooks.

I understand why this is hard to understand -- right now, I have just gotten my first registered pre-release of Olive into Pkg (the first patch of the pre-release, 0.0.91, and there are no extensions yet. With time, I am one person, more extensions will be released and I think this will demonstrate that concept a lot better. I also think #135 (@VarLad) will help with this, making it more obvious how to load extensions and making loading extensions more accessible.

One last thing I will also say on the front of highlighter issues -- if you are having issues with the highlighter, make sure you are on the latest version of ToolipsMarkdown, you can check your version like this:

julia> using Olive.ToolipsSession; using Olive.ToolipsMarkdown

julia> pkgversion(ToolipsSession)
v"0.3.5"

julia> pkgversion(ToolipsMarkdown)
v"0.1.4"

These are the latest (and greatest) versions of the packages. The problem you encountered with the exponent is actually an issue with the ToolipsSession package. I opened an issue for it there. https://github.com/ChifiSource/OliveSession.jl/issues/1

That being said, I would also recommend upgrading highlighters, I think the version step is actually pretty substantial there -- and it makes sense for reporting issues to be on the latest, to upgrade just do

pkg> add ToolipsMarkdown

in that environment. Any issues concerning this, (you will get a stacktrace from ToolipsMarkdown) can go here.

As for the other issue, I will take the time to pinpoint all of these things.

For your final paragraph -- yeah, it is terrifying. I tried using various different packages for essentially everything in Olive. You must understand that the design of Pluto is incredibly different to that of Olive -- Pluto is built primarily in Javascript, Olive is built atop a fullstack web-development framework for julia in nothing but Julia code, aside from some JavaScript strings of course that run on the client. Point being, yeah it is not optimal at all that I had to build most of the things to support this -- it means I have an entire web-development framework to maintain now, as well as a bunch of extensions. It is not the easiest thing, but I promise you I am dedicated. Olive is still working into its form, and a 0.1.0 release is still a lot of issues away -- Olive will continue to improve, as will all of these dependencies I have created -- and it seems to have gone reasonably well so far, at least!

Again, thanks for your issue -- your comments and concerns, it is helpful to think about these things and also have them written somewhere for everyone to hear. I know I have been seeing your name all for years, and I appreciate you making your impact and contributions in the Julia space, and to my projects. Have a lovely day :)

emmaccode commented 8 months ago

closing this :)