1. 4

    I wrote up something very similar to this back in May 2020.

    1. 2

      This is great.

      As others have pointed out, an export button would be great. Support for images would also cover a lot of use cases.

      But let.s not miss the beautiful simplicity of this self contained solution. Even installing or configuring nginx, simple as it might be, is not free.

      This is great for intranets, hackatons, or even small temporary websites exposed to the web.

      1. 2

        There is an “Download Data” button that points at: https://rwtxt.com/DOMAIN/export, but it exports markdown files, not HTML as some commenters wished for.

      1. 1

        what is bag in this line: code-src/bagatto/demo [master !] ⊕ bag index.janet ?

        1. 2

          bag is the name of the executable…. bagatto is the program.

        1. 5

          CTWM is an X11 Window Manager. It was created by Claude Lecommandeur Claude.Lecommandeur@Epfl.Ch in 1992 as a fork of the TWM window manager.

          Thanks for the sharing. I knew ctwm existed, but didn’t know that it was forked 1992 :)

          Besides all the available “tiling” options that we have around while using any opensource OS, ctwm seems to be a safe default for those that need a minimum desktop with auto-generated menu entries to easly access basic software after an install.

          1. 2

            Your comment is a good summary of “why” anyone should be interested in a WM originally written in ’92. It is an interesting piece of software to try out.

            1. 1

              I usually just use twm if I’m just installing a quick X windows system. It’s still totally fine for managing terminal windows, which is basically all I use X for, anyway.

          1. 2

            I installed and played with it. Got a blast of nostalgia of seeing these similar desktops in Engg design department. And it feels really fast!

            90s aesthetic is a thing. Can’t wait to try out SerenityOS one of these days.

            1. 9

              It seems that there are some newish Lisps that are heeding the lessons of the latest crop of successful programming languages: they’re focusing on dev experience, tooling, and documentation to a greater degree than many of the earlier generations. I wonder if that seems to be the case to others.

              1. 3

                For someone trying to learn LISPs right now, are there any others from this crop you could share or recommend? I’m enjoying the family of languages, but am feeling almost universally underwhelmed by the development experiences.

                1. 6

                  For the next release of Fennel we’ve been focusing on friendliness: a setup guide, compiler error suggestions, readline completion and bracket matching, simplified installation, and the ability to debug macros by expanding them in the repl.

                  1. 5

                    racket has an excellent development experience. I’ve tried and enjoyed clojure and chicken scheme in the past but these days racket is my lisp of choice.

                    1. 4

                      can you share what’s your development experiences have been so far with Lisps?

                      There are multiple Commercial Lisps ($$$) with excellent IDE support; eg– Lispworks, Allegro etc.,.

                      Most open source lisps(and schemes) have integration with Emacs (of course). Some people also use vim for their lisps, though that’s still considered somewhat counter-cultural.

                      Clojure has CIDER for emacs, cursive - an intelliJ plugin, light table (no longer developed, AFAIK), and even a VScode plugin.

                      Gerbil has something similar to CIDER called treadmill

                      1. 2

                        Sure! I’ve been mostly working with sbcl CL, Guile Scheme, and Chicken Scheme. I’m very familiar with Emacs, so getting Slime set up was no problem.

                        What I’ve struggled with is the path to A) managing dependencies well, i.e., locking (most things I get the sense just always pull the latest version of things?), and B) figuring out a standard path to deployment.

                        The issue might just be documentation or steep learning curve, but coming from, say, the first few steps in a language like Rust, where the first steps are:

                        1. get rust with rustup
                        2. create new project with cargo new
                        3. edit some code
                        4. build code, copy compiled executable somewhere

                        Trying to figure the analogous set of steps in lisps just seems to require learning many tools and making many decisions: e.g., quicklisp vs asdf vs buildapp.

                      2. 3

                        I’ve had good preliminary experiences with Janet. But I haven’t put it through its paces yet; I want to build a multi module CLI app before I claim victory.

                    1. 4

                      I looked at Gerbil a while ago, and didn’t get super excited for some reason. Looking at it again, briefly, all I can say is “I wish I had more time to fully digest and play with this! It looks very much like what I’ve been looking for!”

                      1. 3

                        yes, the new website and documentation is of much higher quality than it’s original avatar. It actually has standard libraries, package manager, build tool etc., that one can use to do “useful things”, not just play with the language.

                        1. 12

                          and technical blogs: https://lobste.rs/s/l7b3iy/

                          1. 3

                            This one’s from five years ago though. It’s nice to ask again and see people who started blogging in the last five years or who weren’t on lobsters five years ago.

                          2. 1

                            Oh this was asked before sorry i sparked this thread again

                          1. 3

                            Nice, but there’s not much to it. I guess that’s the point. I like minimalism. And it’s obviously light weight.

                            This reminds me a bit of these websites that were going around a while back:

                            1. 10

                              Better comparisons to this classless CSS framework are:

                              1. 1

                                Cool, I hadn’t heard of those.

                                The first two I linked to are classless though, right?

                                1. 2

                                  the creators of those websites were going for “you can put up a half decent looking webpage without making it heavy with fonts, CSS frameworks, and JS”. You can ofcourse borrow their css files to get a minimalistic styling for the HTML page.

                                  The two “frameworks” I linked, much like the item under discussion, were designed to be used with semantic HTML without the need to use special classes or div layouts (like you would when using say bootstrap). They also provide styling for most commonly used elements like forms etc.,which the MFW sites lack.

                                  The good thing about classless/semantic CSS styles (framework is probably too heavy a word to use for a css file), is that you can either hand write HTML or use a generator like pandoc and apply these styles to get a nice layout without worrying about figuring out how to use Bootstrap, Tailwind etc.

                                  Eg: I use water.css on my website where 90% of styling is from water.css.

                            1. 3

                              Mirage Project’s Irmin. “Irmin - A distributed database built on the same principles as Git”

                              1. 1

                                Makes me think of how Elm is able to recompile so quickly so that you can see your changes “instantly”. Especially if you’re working in something like glitch.com, I can see my changes within a second of when I stop typing.

                                1. 2

                                  made me think of Pharo/Smalltalk actually. You can query/modify and interact with the entire system (and not just the parts of code you are writing) in “real time”.

                                  1. 2

                                    Yes. This is what Alan Kay was evangelizing, even as far back as Smalltalk-76. He credits Simula 67 and Sketchpad. Squeak, the portable Smalltalk-80 implementation originally developed at Apple, is the direct ancestor of Pharo. The Morphic UI (replacing the old MVC in Squeak) is strongly influenced by the same ideas.

                                    1. 1

                                      “Rebuild quickly” and “live systems” both make implementing some of these ideas easier but I think the real issue is scaling this up and across the whole system. Not only should this be the default mode of all programming, it should also work for getting a sense of large scale changes that span multiple processes and machines.

                                      I was thinking the core model of working would change from “rewrite, rebuild/rerun and review output” to “project and manipulate” where project involves creating a projection/view of your system that shows the behavior you want affected.

                                1. 5

                                  Time to upgrade this benchmark of scheme implementations?

                                  1. 2

                                    Thanks for this. Even since I saw this [1] I have been looking into Lisp. I started looking and realize its a pretty big community with many dialects and implementations

                                    1. https://fodor.org/blog/webassembly-hello-world
                                    1. 8

                                      -Wpedantic: webassembly isn’t a lisp, it just uses s-expressions for describing its text format.

                                      1. 1

                                        To quote you 7 months ago: “unreadable langauges with too many parenthesis”, let me know how your search goes.

                                        1. 1

                                          Honestly I stand by that. Every example of Lisp I have ever seen, looks like this:

                                          (sunday 10
                                             (monday 11
                                                (tuesday 12)))
                                          

                                          Where the linked syntax looks like this:

                                          (sunday
                                             10 (monday
                                                11 (tuesday 12)
                                             )
                                          )
                                          

                                          Style matters. Its a small difference, but to me its markedly more readable.

                                      2. 1

                                        By the look of the raw numbers, guile has to be much more than an average of 2x speed up to be any where near chez.

                                        1. 2

                                          “Compared to 2.2, microbenchmark performance is around twice as good on the whole, though some individual benchmarks are up to 32 times as fast.”

                                          So depending on how “around” rounds off, it may be. :-)

                                        2. 1

                                          I was surprised to see that gambit overtook Chez. I honestly have no idea who uses it.

                                          1. 1

                                            That’s a combined statistics of gambit and gerbil. I use gerbil for small stuffs.

                                        1. 1

                                          https://www.btbytes.com - personal site that’s been online since 2003 and has gone through multiple backends. Now its generated using a bespoke python script. I’m not a regular blogger. The most “interesting” section would probably be the notebooks, one of which is the interesting programming languages which saw few comments on this site. Since I’ve been off twitter since the beginning of 2020, I’m using the log section as a place to jot down things I might have been posted on twitter instead.

                                          1. 1

                                            I extracted the domains listed here and put it on a site “lobstersweb” using shell script, pup, pandoc, makefile and zeit.co.

                                          1. 2

                                            In summary, you can do something like this:

                                            1. execute regular java programs with - jbang helloworld.java
                                            2. the jbang is a play on shebang #! and looks like this (at the top of the file) - //usr/bin/env jbang "$0" "$@" ; exit $?
                                            3. include package dependencies with a line like this – //DEPS log4j:log4j:1.2.17
                                            4. inspired by Kotlin’s kscript utility
                                            1. 1

                                              I went from vim to sublime to vim around 6/7 years ago. This was back at sublime V2 though I think where it was a crapshoot what you were going to get when you installed a plugin, if you managed to filter through the 30 odd ones for what you wanted. I still have v3 installed but only use it sporadically to edit plaintext or copy text. I used IntelliJ for a while, but once my main project got bigger, the typing lag started to drive me completely insane and I went back to vim. I tried vscode, but it just felt like baby IntelliJ and I don’t want to go down that road again. IntelliJ starts to force you into a situation where your project could easily be a bad time for another developer joining that doesn’t have IntelliJ and vscode felt like that in its infancy.

                                              I do try these things. Sometimes for extended periods of time, but I always end up back at vim just because it’s ubiquitous for me and the typing lag though not nonexistent, is still pretty minimal at the worst of times. I can work around everything else I need like debuggers and build systems, but if the editor typing lags it’s like fingernails on a chalkboard for me.

                                              1. 2

                                                i’m a fairly decent vim user. My problem with becoming a “power” vim user has always been about the explosion of options once you step out of “a few configs in .vimrc” range.

                                                1. 1

                                                  Yeah I completely understand where you’re coming from. It’s gotten better over the years though, it used to be in order to support different languages, plugins and stuff you had to put a metric ton of effort into your .vimrc file. Nowadays I take a “less is more” approach to things, I think my .vimrc file is only about 200 lines and I use ~10 plugins through Vundle with minimal configuration changes. I’m pretty brutal about cutting out a plugin if it’s problematic or doesn’t do what it says on the tin, or it’s something I can just do on the command-line or in a Makefile/sh file.

                                                  I use iterm2 instead of tmux as I can’t seem to keep all the keymappings in my head so I can use the mouse to split views, resize them, etc…

                                                  To be honest, IntelliJ and Sublime both have vim emulation layers you can install/enable. But at the end of the day (for me) it literally boils down to the typing lag. I’ll go with whatever lets me write my code the fastest without frustrating me and it just seems to be nvim at the moment that has that in spades, though I may look at Sublime again and try the vim emulation layer with it, but no one ever has an ergonomic keymapping to go from the editor to the file tree and navigate that with vim keystrokes that I’ve seen.

                                              1. 4

                                                Is Smalltalk the new Clojure, lacking only real world applicability?

                                                I should explain. Two marvelous ideas entered the marketplace last century. One fell apart because it was seen as the domain of AI and academics, with implementations being too like forth (you learn one forth, and you’ve learned one forth) for people’s likings. The other was embroiled in legal battles and refused to acknowledge that it wasn’t the computer. This was quickly deemed, though not obvious at the time, unacceptable. Even C doesn’t care what the kernal is, so long as it has a standard library, and polyglot systems are just More Useful.

                                                I speak, of course, about LISP and Smalltalk.

                                                Clojure is LISP made Really Useful. It can be used to glue Java together with almost no code, runs on possibly the most popular and recognizable virtual machine in the world, and the functional twist took out a lot of the dark corners out of the language

                                                Clojure made LISP usable.

                                                As for Smalltalk, the Pharo VM does a great job of being modem, using the Cog JIT engine, and even (in an upcoming release?) being able to respect the world outside the VM. I love the language, one person describes it as an unhealthy fascination, and I would recommend people learn the lessons of Smalltalk.

                                                As for me, I learned a lesson from the failures of Smalltalk, and it isn’t one people think about. I want to codify my ideas as a language, as soon as I have the time to do so. I want to make Smalltalk applicable to server operators and packagers. Blog posts on the topic to follow.

                                                1. 4

                                                  Smalltalk had a resurgence some 10 years ago with interest in the Seaside web app framework and a few hyped Smalltalk web apps. I recall DabbleDB as one that seemed impressive at the time.

                                                  If you haven’t yet, I’d suggest looking at Strongtalk, Self, and Newspeak. And what the space between them and Objective-C looks like.

                                                  Good luck!

                                                  1. 2

                                                    To quite some extent I think the space between ObjC and Smalltalk-likes is occupied by Ruby. More Smalltalk-like than ObjC, easier C (or really, host platform code in general) FFI than a Smalltalk.

                                                    1. 1

                                                      It really is, but Ruby has a bad rap these days, no advantage Python doesn’t in the realm of writing usable code, and an unfortunate load average and dependency story.

                                                  2. 4

                                                    Clojure made LISP usable.

                                                    I have to disagree with that. Lisp is very usable (and quite nice) on its own. Perhaps Clojure made it usable for gluing Java together, but huge swathes of the software world don’t involve Java, and are still well suited to Lisp.

                                                    1. 3

                                                      I love Scheme, but I’ve tried to learn Common Lisp a three times times, and each time I got frustrated. Whether because the lack of Vim support (I can’t be bothered to learn emacs, and it just confuses me), or because quicklisp doesn’t do what I expect, I can never quite understand what’s going on under the hood. It’s a shame too, because I’m fascinated by some of the cool CL projects like CEPL.

                                                      However, if we’re including Scheme, I also disagree with the statement that Clojure is the first usable language in the Lisp family. Guile and chicken scheme are both very easy to get started with out of the box, and Racket has a full on IDE geared towards education, superb technical documentation, and tutorials that makes it easy to get started.

                                                      1. 1

                                                        you know there are perfectly good IDEs for Lisp that are not Emacs? Clozure Lisp (CCL) [Opensource], Lispworks personal edition [Free].

                                                        And there is nothing stopping you from using Atom, Visual Studio Code or Sublime text with Lisp plugins.

                                                      2. 2

                                                        I’m afraid I also disagree. Lisp users before Clojure are of a different breed entirely, a more skilled and arcane breed. Clojure is accessible to and used by the masses to write useful code and libraries.

                                                        1. 3

                                                          That’s flattering (I guess), but I’m not sure it’s true. By some measures Common Lisp is still more popular than Clojure.

                                                          TIOBE’s language ranking isn’t perfect, but it’s better than nothing, and it claims Clojure and Common Lisp are both down in the 50-100 group, behind generic “Lisp” at 32 and Scheme at 34.

                                                          However, “Lisp” is often taken to mean “Common Lisp” nowadays (for example the #lisp IRC channel is dedicated specifically to Common Lisp), so those rankings may be interpreted as meaning CL is more popular.

                                                          Also, I wold claim CL is at least as accessible as Clojure. It’s not as trendy, but it has more implementations, supports more platforms, isn’t tied to the JVM, and has a bunch of tutorials and books covering it.

                                                          And of course there are plenty of useful libraries and applications being written in CL today.

                                                          1. 1

                                                            Originally learned about Lisp from AI books. That would make me agree with you. Then, later books like Practical Common Lisp and Land of the Lisp are way more approachable better things for mainstream audience to build. Important they get that IDE that allows incremental, per-function compilation. That by itself might win them over. Alternatively, they can start with Scheme using How to Design Programs trying Common Lisp if they get HtDP.

                                                            I have a feeling you’ll see a lot more people in it if the educational resources, community, and tooling facilitate the learning process. In that order for Lisp.

                                                      1. 9

                                                        I think TCL is underrated. A syntax similar to shells is great. Well, actually I think TCL is too complex. So maybe a smaller descendant like TH3.

                                                        I find languages like Lua or Javascript are too powerful. They get used to write entire applications and that is too much. Embedded scripts should be small and easy to understand. Providing powerful features misleads people into writing larger and complex scripts. If you want to go that way, then I would suggest to extend Python instead.

                                                        Another interesting language I stumbled upon recently is SparForte. It allows you to write small scripts (think bash) and when they (inevitably) grow, you can transform them piecewise into Ada. The approach is similar to starting with Python and extending it with Rust where necessary. The advantage is the language is explicitly designed to support that use case.

                                                        1. 5

                                                          I find languages like Lua or Javascript are too powerful. They get used to write entire applications and that is too much. Embedded scripts should be small and easy to understand.

                                                          It’s pretty easy (like on the order of five lines of code) to take a chunk of Lua and sandbox it so it doesn’t have access to any libraries; even stuff in the standard library. The core of Lua is trivial to learn for anyone who has programmed before; you can pick it up in an afternoon.

                                                          1. 4

                                                            Brr. I actually I think it is massively overrated.

                                                            Scheme and the “designed to be embedded” flavour Guile is much nicer.

                                                            1. 1

                                                              Thanks for the SparForte reference, that looks interesting.

                                                            1. 4

                                                              Nice. What makes this opinionated though?

                                                              1. 4

                                                                Nothing is adjustable

                                                                1. 3

                                                                  I’d argue this is software more adjustable (<100 lines of code that is really opinionated “configuration” of libraries) than a more “configurable” behemoth with 200 files.

                                                              1. 8

                                                                Whenever I read about yet another GUI toolkit that doesn’t use native widgets, I want to scream, “No! Don’t!” Here’s a comment that succinctly lists several problems with non-native widgets. Many of them are macOS-specific, but some are applicable to any platform.

                                                                1. 8

                                                                  while this appeals to the purist, we are no longer just dealing with the QTs and wxWidgets of the world. The evil facing us is a multi-100mbs heavy electron app that eats similar amounts of RAM for showing a few widgets on screen (eg: privtunl’s toolbar).

                                                                  1. 3

                                                                    “Evil” is an awfully strong word in this context. For all of Electron’s problems, at least it inherits Chromium’s support for platform accessibility APIs (on Windows and Mac). This makes Electron infinitely better for, say, a blind user who relies on a screen reader, compared to a typical non-native GUI toolkit with no accessibility support. Of course, for many users, like the author of the comment I linked previously, a truly native GUI would be better still. But let’s not block some users from using our applications because Electron offends our aesthetic sense.

                                                                  2. 4

                                                                    I have not tried it, but for native widgets there is also https://github.com/briskml/brisk that seems promising

                                                                    1. 2

                                                                      What can someone even use to make cross platform native apps with native widgets? I’ve been looking for a desktop UI framework to use but it looks like the only “good” way is to rewrite the UI once with Cocoa, once with whatever Windows uses (is there even a standard?), and once with GTK+.

                                                                      1. 3

                                                                        Things like wxWidgets and Eto use native widgets. Of course the result is going to look a bit weird because macOS, Windows and GTK have very different UI idioms and showing the same UI everywhere would look out of place everywhere (except Windows, where inconsistency is kinda the norm, and MS has multiple independent UI toolkits as part of the system). But with great effort, you could put platform specific adaptations with these frameworks and make it look okay.

                                                                      2. 2

                                                                        I think this only applies to mac. And even then only minimally.

                                                                        Linux doesn’t even really have a native, there’s qt, gtk, and then <random other apps> that all make up the core parts of any given system and all style differently.

                                                                        Windows technically has a native, but not even microsoft seems to care about it anymore.

                                                                        The vast majority of time spent on most computers is probably in the web browser, which on all platforms does not look “native”.

                                                                        Arguably “native” these days should probably mean “imitate the web” not “use OS APIs” since that’s what most people are “native” to anyways.

                                                                        1. 1

                                                                          I think this only applies to mac.

                                                                          Almost certainly. There are many people who use a Mac because it’s Unix with a usable interface; many (although fewer these days) who use them because it’s what they had in school; but there are some, and this is a shrinking minority, I fear, who use Macs because they prefer the Macintosh, and they make an affirmative choice to dwell in the Mac, and select their tools based on how well they conform to platform convention. This is not a thing that people who prefer Windows or non-Mac Unixes has ever used as a decision procedure.

                                                                      1. 6

                                                                        So I just skimmed the docs for a quick second, and it states that react-native essentially “packs a browser” into an app, hence the high cpu/ram usage, but then the readme sort of just denies this is a problem for revery? Without really explaining why? Hate to be that ignorant fool in the thread, but could someone explain to me how exactly this works? I’m not a frontend/js guy, and I love ocaml, but I have no idea how any of this stuff is supposed to work. How is something “native” if its not actually locally compiled machine code? thanks in advance for any takers on this

                                                                        1. 4

                                                                          The same Reason/OCaml code will compile down to / bind to the low level graphics libraries (ie., GL) when targeting native platforms and the “OpenGL” parts of the browser when targeting Javascript.

                                                                          1. 2

                                                                            thanks for taking the time to explain.