1. 1

      IUP is a good option: https://www.tecgraf.puc-rio.br/iup/ It wraps over Gtk+/Qt/Cocoa, it has bindings to many languages (core in C), it has a small API which makes it easy to learn (message-passing-like instead of lots of methods), it has a lot of widgets (but I missed one: a tree table with columns), it has ongoing work for iOs and WebAssembly.

      1. 4

        Common Lisp, because it has the fastest write-test cycle I know of, while still giving lots of compilation warnings (when we compile one function with a keystroke), it has more libraries than you think, I love the comfy and consistent syntax, and we can build executables. I wouldn’t go with Python anymore, I am not happy with the development workflow, the type checking and the deployment story (specially if I want to deploy a fleet of apps). I am lurking into other languages, but they always miss something CL has :] Oh, and I really want to try the hot reload capacity. I must be great for small updates. With Python if I want to deploy a quickfix it impacts the app’s availability (by not much, but users still face a buggy app for a couple of minutes).

        1. 5

          To dive int CL, my preferred links:

          1. 6

            Wow this is really incredible. Makes me want to learn Racket.

            MUST… RESIST… URGE TO CHASE BRIGHT SHINY!!!

            :)

            Years from now when I reach near Expert level Python Racket or Clojure are definitely my next language choice.

            1. 7

              Check out https://beautifulracket.com/ you might like it.

              1. 7

                NOOOOOO ahem Thanks :) I filed that away for a time when I can use it guilt free :)

                I know being LASER focused and not branching out at all seems counter-intuitive in this polyglot world of 2019 but I spent years mastering NOTHING and as such my core skills never got to where they needed to be. My rigid blinders around anything non Python have paid off in a huge way already so I’m sticking with it for the nonce :)

              2. 1

                it’s a really pleasant language! i highly recommend it. in particular, if you ever want to develop a small cross-platform gui app with high developer productivity it’s one of the best tools i’ve found for the job.

                1. 3

                  When you say small GUI are there patent limitations? (lack of useful widgets?)

                  1. 1

                    it doesn’t have as much in the way of widgets as e.g. qt does, though it has all the standard ones and a canvas so you can make your own. another drawback is that there aren’t that many people writing gui apps in it, so even though it is relatively straightforward to create custom widgets, in practice there is a poor specialised widget ecosystem (e.g. there’s a map widget because someone made one, but i couldn’t find a date picker/calendar widget in a brief search).

                    it also suffers from a lack of niceties like theming, and misses features like accessibility and internationalisation. see this bug for more. the gui framework was largely developed to build the drracket ide, and that tends to show in a lot of places.

                    on the other hand it really does make it easy to write a quick gui app for some small, specialised task. the main hurdle again is that there are not many tutorials and examples out there, so getting started can be a bit slow, but once you get familiar with the basic gui framework it’s a pleasure to use. and it has some surprising widgets, such as a hypertext widget where the links call back into racket code, and a 3d renderer.

                    1. 1

                      Thanks! It’s exactly what I thought about Ltk (I’m turning to the IUP bindings now).

                      1. 1

                        from racket? i think i tried once and had trouble getting them working; if you can’t then the chicken scheme binding is well worth checking out.

                        1. 1

                          hey sorry, no I tested the Common Lisp bindings (ltk and IUP).

                  2. 2

                    Racket seems rather unique in that it’s a Scheme with an unusual bent towards solving real world problems, and it seems to have a really vibrant community of people doing just that and providing a really solid and diverse library ecosystem.

                    I look forward to learning it… In the future :)

                1. 1

                  The worst is that traumatic changes in python (and nearly any other language) will appear again… my alternative is a lisp language. You can add any language feature you want with the same syntax. And in the case of CL, you can even program the syntax reader: you can make that in your source files, { } will denote a dictionary, use @-decorators, etc. Without ever waiting a language update, or breaking existing libraries. CL is famous for its stability. Code written in the 90s (and probably before) can still run as is.

                  Then, async support depends on the implementations. That’s what is possible in CL: https://github.com/CodyReichert/awesome-cl#parallelism-and-concurrency

                  1. 3

                    In my opinion CL avoids thos problem in the worst way possible: no code is actually idiomatic in the ecosystem. It can be idiomatic within a project, but between projects, taking a piece of code from one and putting it into another will result in code that is not idiomatic for one project, but is for the other.

                    1. 2

                      I don’t understand. We don’t copy&paste code from one project to another. The ecosystem is actually pretty conservative. And if we use features from other libraries, it’s like importing a library of pattern matching of futures into python: not idiomatic, just incorporated into your project for your own use.

                      1. 2

                        We don’t copy&paste code from one project to another.

                        Yes, that is the consequence of the choices LISP makes. I argue it’s a bad thing. You need to learn what is idiomatic for every project if you want to contribute to it. Meanwhile in Python, or Go, or C, or almost any other language if you know what is idiomatic within a language, you know what is idiomatic within a project. This reduces the initial thinking overhead for new contributors and allows to easily reuse solutions from other projects in yours. When understanding what it does, copy-pasting code is one of the more powerful tools in programmer’s toolbox.

                        1. 1

                          well even in Python I don’t copy and paste code so we’ll have a short discussion. But regarding lisp, once again the community is quite conservative meaning you don’t encounter crazy new languages atop of it, then looking at the imported libraries one has to learn what they do anyway, exactly like in Python.

                  1. 2

                    This article sort of touches on why I am mostly allergic to javascript. It’s not my primary or even secondary language and the ecosystem changes so fast that it’s a full-time job trying to just keep up with what is idiomatic. I guess it’s not the javascript language itself that is the issue. It’s more the libraries and tooling that create this problem.

                    1. 1

                      Nah, I disagree. Evolving syntax and other (missing) languages features are part of the problem. Lisp languages avoid those trauma…

                    1. 4

                      For the emacs-y browser, there is/will be the Next browser :)

                      1. 14

                        I don’t like the direction he wants to go with HTML and web integration. If I want webmail and web chat and perfect HTML rendering, I’ll open my browser. I don’t think the core of Emacs should be bogged down with a browser engine. I understand that some people want to use Emacs for everything, but at the end of the day it is supposed to be a text editor and not a web browser.

                        It’s easy enough to say “Just turn it off”, but it’s bound to be a security mess, bloat the memory use, and make the code base even more complicated, so there are side effects even for people who don’t want these features.

                        1. 13

                          at the end of the day it is supposed to be a text editor and not a web browser.

                          It’s supposed to be an operating system; more of a Lisp Machine refugee camp, making do with what’s available on Unix.

                          1. 2

                            Maybe, but the modern web is a product of Unix, continued on with technical compromises and consumer friendliness. If Emacs were to become a text browser, sure I would not have to leave Emacs anymore, but the product would really not be the computational environment built on free software any more – rather it would just be reduced to another, probably sub-par browser.

                            1. 2

                              Done right, I think that it would very much not be just another browser, and done right it need not be sub-par. I can easily imagine a Lisp-extensible editor with enough knowledge of HTML, JavaScript and CSS to be indistinguishable from Firefox or Chrome.

                              What I can’t easily imagine is the FSF, GNU or the Emacs project itself having the resources to build such a thing. And sadly, no-one with those resources cares enough about Lisp or Emacs to do it either.

                              1. 1

                                I can easily imagine a Lisp-extensible editor with enough knowledge of HTML, JavaScript and CSS to be indistinguishable from Firefox or Chrome.

                                If it’s indistinguishable, what’s the point?

                            2. 1

                              Guixsd already exists, and uses a better lisp!

                            3. 4

                              I don’t think the core of Emacs should be bogged down with a browser engine.

                              Emacs already has a web browser and if you haven’t noticed it by now then I doubt a new one getting added is going to bogg anything you already use down.

                              1. 3

                                I know, and I use it almost every day. I have it set as my default browser in Emacs. I use it to open Org mode web links, browse documentation, do web searches/research while working, and occassionally use github and sourcehut. It’s nice because I can avoid the distraction of Slack, email, Lobste.rs, and the rest of the web.

                                I guess my argument is that Eww already supports the right amount of HTML for a browser embedded in a text editor. Obviously, very much IMO.

                              1. 10

                                The article matches my experience. Python was my favorite language because [I thought] it had great support for interactive programming, which is the style I’m more comfortable with. After learning CL I know longer think that is true. Python is another batch-oriented ‘dead’ language to me. (And TDD at least allows me to treat it as a zombie ^_^)

                                A minor nit about the hype epilogue

                                JavaScript was written in CL!

                                It is incorrect or at least overselling it. Mozilla had a CL prototype of ES4 iirc, but it was never shipped. Although there is a JavaScript implementation in CL by the author of code mirror: http://marijnhaverbeke.nl/cl-javascript/.

                                The C# garbage collector was prototype in CL though!

                                About iterators, although as the article mentions there are libraries that implement them, in practice (loop :for ... := ...) does the job.

                                1. 1

                                  Hey, I found the links back: https://jorgetavares.com/2010/05/19/original-implementation-of-javascript-in-cl/

                                  “js/semantics contains experimental code used to generate LR(1) and LALR(1) grammars for JavaScript as well as compile and check formal semantics for JavaScript. The semantics can be executed directly or printed into either HTML or Microsoft Word RTF formats. This code is written in standard Common Lisp. It’s been used under Macintosh Common Lisp 4.0, and Allegro Common Lisp 5.0.1 for Windows, but should also work under other Common Lisp implementations.”

                                  We still can see sources: https://dxr.mozilla.org/mozilla/source/js2/semantics/

                                  (taking notes here: https://github.com/vindarel/list-of-languages-implemented-in-lisp/tree/master#javascript)

                                1. 4

                                  I’m improving my bookshops management software (here), and dealing with a lot of technical debt :S (Python2 and Angularjs 1.x…) I’m getting my feet wet for a rewrite in Common Lisp. Currently the very basics work in a readline interface (a handy one, with autocompletion for everything). I didn’t decide on the web frontend yet… I’m productive in Vue, but my dream would be to use Weblocks (it’s seeing a rewrite since a couple years), but I must complete the documentation myself (coming soon: routing). I’d like a simple GUI too. Probably with the IUP bindings.

                                  I’m also trying out isomorphic web frameworks. Last in date: Hyperstack (Ruby & React), but the installation instructions failed for me. I’ll have a look at Rust’s seed-rs, but they all are alpha… I have a little list here. I welcome any feedback. Can we write isomorphic webapps today?

                                  1. 1

                                    Soooo, what is the good CL to use under Windows? I’m asking because most stuff I see seems geared towards *nix.

                                    1. 3

                                      Not a Windows user myself.

                                    1. 19

                                      So why is CL not more popular ?

                                      Because the multiplicity of implementations means that the package you need might not be available for your Lisp and some fundamental feature you need simply doesn’t exist.

                                      Because the standard library is enormous but misses a lot of what the modern user needs. There’s no standard way to do networking in CL, for example. Sure there are third-party and implementation-specific libraries (and good ones) but they’re not just “there”. This only gets worse as the use-case gets more specific: let’s say I want to talk to an IMAP server, retrieve emails, parse them, and then open up a connection to an SMTP server. Python has literally every step of that in the standard library, and numerous third-party implementations of each that all work on the reference implementation of Python (CPython). CL doesn’t.

                                      Because of the mixed metaphors. CLOS is there, and fantastic (better than anything that came after), but there’s also non-CLOS parts of the standard…and some libraries are OO and some aren’t and some are halfway and so on.

                                      If you’re writing a truly unprecedented piece of code, something that no library already exists for, then CL is the better language, but the minute you want to do something with an existing system, you’re suddenly looking at a paucity of support that may or may not even work on your system.

                                      (Note that the slightly angry tone of this comment is out of a…frustrated love. I wish CL had remained at the top, it is a wonderful language. It just didn’t, and I’m disappointed. Maybe things have improved some in recent years? I hope so.)

                                      1. 10

                                        As a big user of Common Lisp, I can tell you that most of those don’t end up being problems in real life.

                                        One of the ideas behind CL is that the language is extensible and the user community can extend it as they see fit. Going with your example of networking, the standard won’t be updated to include it because it can be added by user library. When a library solves a problem well it’ll become popular, get added to QuickLisp, and then it’s available for everybody - no standard update required.

                                        As you point out, Python’s huge standard library doesn’t offer much benefit over Common Lisp’s way of doing it. Python will often have a suitable library in the stdlib, but also third party libraries to do the same thing in different or better ways. Realistically people should check Pip for a better library before using the one in the standard library. It’s really no different than checking for a library in Quicklisp.

                                        And then there’s a maintenance cost for implementations to keep alive obsolete libraries like CGI and optparse in Python.

                                        As far as implementation specific code goes, it’s usually just not a problem. There are “standard but not officially standard” libraries that hide the implementation details in almost every case. trivial-sockets, for example, is the socket networking library that uses macros and inline functions to call into the implementation specific socket libraries.

                                        1. 5

                                          So I used CL a fair bit years ago, and Scheme was my preferred extension language for a long time.

                                          (Ironically, though, I’ve never liked Emacs…)

                                          The standard-but-not-standard stuff is, IMHO, a problem for people getting into the language….it may not be a problem for experienced users, but approaching the language from the outside you’re going to say “Common Lisp can’t do networking?!?” and then look at Rust/Python/Go and see that all the stuff they want is already there. They’re not going to know about QuickLisp or whatever.

                                          (Yes, Python has pypi/pip, I know, but you can do an awful lot of “real world, modern” coding in Python before you have to resort to PyPI. Same with Go, etc.)

                                          The other problem, and like I said this may have changed, is that not everything works for every implementation. I recall CLISP not supporting some sort of library that seemed fairly important, while SBCL did (or vice-versa). So that adds onto the problem of having to choose an implementation on top of choosing a language.

                                          (Note that it’s not quite the same as C/C++. With those languages, you’re generally using operating-system-provided facilities so the compiler matters less, and the STL is also reasonably comprehensive on top of that.)

                                          Again, all this is just IMHO.

                                          (And I’m old enough to remember when you had to roll most of your own stuff regardless of what you were doing…good times, but I’m too old for that now.)

                                          1. 6

                                            By this metric C can’t do networking, yet it’s doing OK.

                                            1. 1

                                              C can’t do many things compared to Python, at least not easily or well, but can do others. Let’s try to compare apples to apples.

                                              1. 4

                                                The point is not C vs Python, is that the claim that C can’t do networking is patently false. And C doesn’t have networking in their standard. Ergo not having networking as part of your standard is not an impediment to have good networking support.

                                                1. 2

                                                  C is however more practically important language, and again doing fine without networking in the spec.

                                                  We can’t compare CL to Python anyway as Python is not standardised.

                                              2. 5

                                                The standard-but-not-standard stuff is, IMHO, a problem for people getting into the language….it may not be a problem for experienced users, but approaching the language from the outside you’re going to say “Common Lisp can’t do networking?!?” and then look at Rust/Python/Go and see that all the stuff they want is already there. They’re not going to know about QuickLisp or whatever.

                                                I don’t think that’s a realistic situation. If a new user is given documentation about the Rust/Python/Go libraries, they can just as easily be given documentation about Common Lisp’s libraries.

                                                1. 3

                                                  The standard-but-not-standard stuff is, IMHO, a problem for people getting into the language….it may not be a problem for experienced users, but approaching the language from the outside you’re going to say “Common Lisp can’t do networking?!?” and then look at Rust/Python/Go

                                                  I would expect new comers to read their implementation’s documentation not saying CL can’t do networking: http://sbcl.org/manual/#Networking That is what I did with Python and Ruby.

                                                  1. 1

                                                    The other problem, and like I said this may have changed, is that not everything works for every implementation. I recall CLISP not supporting some sort of library that seemed fairly important, while SBCL did (or vice-versa). So that adds onto the problem of having to choose an implementation on top of choosing a language.

                                                    This is not a problem. Every modern resource will say: “just install SBCL now”, and nobody recommends CLISP today (although it’s still developped, that could change). De-facto standard libraries are well referenced.

                                                    I encountered an actor library made for CCL (open source) and another one for LispWorks. That’s the only moment I saw a difference so far.

                                                    If newcomers find the Cookbook, they’ll be fine :) https://lispcookbook.github.io/cl-cookbook/getting-started.html

                                                    1. 2

                                                      nobody recommends CLISP today

                                                      That makes me sad. CLISP was where I got started with Lisp…

                                                      1. 2

                                                        CLISP was unmaintained for the last decade, although it has seen a resurgence in activity in the last few years. CLISP has a great CLI REPL, which is what newcomers will first try to use.

                                                        1. 1

                                                          Almost a thing in common. My experiments went from Lisp-in-a-box -> CLISP IIRC. Long time ago, though.

                                                        2. 1

                                                          Hey Vincent, nice post on the post and kudos for evangelizing CL while keeping a positive attitude. You rock!

                                                          1. 1

                                                            wooo, thanks :)

                                                    2. 5

                                                      I mostly agree with the observations you make about CL but disagree with most of the conclusions. The only observation I disagree with is

                                                      Because the standard library is enormous but misses a lot of what the modern user needs.

                                                      CL doesn’t have an enormous standard library, which is why, as you mention the standard doesn’t include a lot of the the modern user needs. But that is the job of implementations. SBCL comes with networking, threads, timers, a test framework, mailboxes, an FFI. Commercial implementations such as LispWorks come with even more libraries.

                                                      The only thing that I constantly wish CL had as part of the standard is built-in sets.

                                                      There’s no standard way to do networking in CL, for example. Sure there are third-party and implementation-specific libraries (and good ones) but they’re not just “there”

                                                      That is a commonly raised objection, but it makes no sense to me. Do people program w/o using GCC built-ins? Why would I not consider the documented libraries of my implementation as being there? Recently I’ve writing a Gopher client, the protocol implementation is ~100 LoC on SBCL w/ no dependencies (using sb-bsd-sockets). I didn’t have to go shopping for libraries. Just download the RFC and start hacking!

                                                      Because of the mixed metaphors

                                                      It is true that CL has mixed metaphors, different parts of the language have different objectives. But that is a necessity for a general purpose language, especially in one that wants a uniform view of the work. Lisp is a jealous god after all0. Mixed metaphors are not pretty, but they are a thing that CL gets right.

                                                      looking at a paucity of support

                                                      If one wants support, Lispworks and Franz are always there, they provide you with a lot of the standard library you asked for.

                                                      (Note that the slightly angry tone of this comment is out of a…frustrated love.

                                                      Your comment doesn’t read as angry to me. And there is a lot to be frustrated wrt Lisp’s history. What frustrates me the most is that due to lack of resources and experience reports ‘we’ (Lispers) haven’t been able to move Lisp past CL. One can read Baker’s critique of the DIN Kernel Defintion to see how much CL could be improved for the application programmer (Spoiler for rust fans, it involves linear types). I wish we would have moved past CL. I wish the MOP would be fleshed out more. But alas, all I can do is wish (and program in Lisp of course, it is still a great language today)

                                                      Quoting below the Jealous God reference because linking to google groups suck

                                                      You make a good point about the importance of environments. That’s precisely the advantage of Lisp. You get a uniform picture of the world – everything is Lisp. You don’t have to know anything about machine language, assemblers, linkers, and all plethora of itty bitty ‘tools’ with <3-character names. You have the same language for writing macros, the same language for writing system code, the same language for writing scripts, the same language for writing editor extensions, the same language for interacting with windows, etc.

                                                      Now some would consider this sameness a negative, and with most languages it would be. But with the power of Lisp as an ubiquitous extension language, I don’t have to memorize all sorts of ‘special-purpose languages’, each with different syntax, different naming conventions, different shadowing semantics, different versions of ifthenelse, dowhile, etc.

                                                      Lisp is the ultimate ‘fractal’ language, because it is good at all levels, from microcode to shell scripts.

                                                      1. 1

                                                        “But alas, all I can do is wish (and program in Lisp of course, it is still a great language today)”

                                                        Nah, it’s Lisp: you can implement the better features and paradigms as macros in CL. Then, get their benefits even while the purpose-built language is still an academic prototype. ;)

                                                      2. 5

                                                        I have used CL only for small personal projects but so far I can only agree with @jlarocco that working with QuickLisp has been a very good experience. Libraries are easy to install (at runtime, no reload!) and typically quite reliable. Not everything is well documented but the nature of CL makes it easy to browse around and dig in.

                                                        Coming from Smalltalk I really started loving CL for its interactive workflow and expressiveness. And I was more than once surprised by the performance of code generated by SBCLs JIT. With all that I would really love to work on a CL project professionally.

                                                        That said, I think similar to Smalltalk, the versatility of the language is the main inhibitor of success. http://www.winestockwebdesign.com/Essays/Lisp_Curse.html lays it out nicely - a programming language that is standardized, not too crazy, and easy to onboard people to probably fits the needs of larger and large projects better.

                                                        1. 2

                                                          Coming from Smalltalk I really started loving CL for its interactive workflow and expressiveness.

                                                          I thought Smalltalk was the most interactive platform ever O_o

                                                          With all that I would really love to work on a CL project professionally.

                                                          thanks to my blogging and other activities I was contacted this year to work for 2 months on a website :) Now, if all goes well, I’ll have an opportunity for six months… so, do stuff, contribute and show it :)

                                                      1. 1

                                                        I’ve seen this before and looked a little bit into it, can anyone share their experience with this?

                                                        Email is becoming such a liability for me. When I switched off gmail a while ago (now I have completed de-googlifying my life!) I had some trouble finding another provider.

                                                        I did not dare to self-host (figured it would be labor intensive…) but the paid services are basically:

                                                        • FastMail :: Australian policy on software is probably some of the worst informed decision making on the planet. Also this is pretty much the only recommendation made when people talk about finding an alternative to google, so it’ll just repeat the same problem of one provider owning email.
                                                        • Protonmail :: in my opinion they act in bad faith by not packaging for fdroid and they have this tinge of corporatism (more than a tinge tbh..) that I don’t trust.
                                                        • Something else? DDGing just now gave me Yandex, AOL, Yahoo and some other things that are obviously out of the question. Ooh actually there is something called tutanota, going to look more into this I guess..

                                                        I’d be interested in a NixOS flake that has configured an email server for you so that self-hosting can be made easy, please let me know if there is something like this out there! :)

                                                        1. 2

                                                          I’ve seen this before and looked a little bit into it, can anyone share their experience with this?

                                                          I gave it a shot. It’s very nicely implemented except for the fact that, well, email isn’t the best backend for instant communications. It’s slow, and the delay really affects conversation.

                                                          I did not dare to self-host (figured it would be labor intensive…) […]

                                                          I’ve been self-hosting for the better part of 3 months now, and it’s really not that hard. The first time setup will take you a couple of hours tops, but that’s it. It’s very low maintenance.

                                                          Ooh actually there is something called tutanota, going to look more into this I guess..

                                                          I’d recommend against using Tutanota, they don’t offer IMAP/SMTP support.

                                                          1. 1
                                                          1. 5

                                                            and on the developer experience? is the compile time bearable? How’s editor integration, can there be some sort of a repl? How are the error messages? thanks

                                                            1. 4

                                                              How’s editor integration

                                                              I think that the most Nim developers are using VS Code. I personally use NeoVim with this plugin, which, IMO, makes the experience even better than the one in VS Code.

                                                              Fun fact: three core developers use three different editors: VS Code, Emacs, NeoVim.

                                                              1. 1

                                                                It has a kinda proto-repl feature called “hot code reloading”. It needs some initial setup, and doesn’t give you the typical repl experience as is, but most certainly should allow for live coding (I haven’t tried it myself yet), thus I assume it qualifies at least as “some sort of repl”? :)

                                                                1. 0

                                                                  The VS code integration is quite nice. I’ve had fairly good experience with error messages. The compile time is very low, and seems to be less than Go’s compile time, at least it feels that. There can be a REPL of sorts, if you type nim secret, but it’s not a fully featured thing.

                                                                  1. 1

                                                                    Do we really need a post here for every little version update or request for money for this app?

                                                                    1. 3

                                                                      Well, I for one am interested — but I’m also a sponsor, and hopefully soon a user. It’s really exciting to see something come out which could be the Emacs of web browsers. Now if only it had a decent editor …

                                                                      1. 1

                                                                        I think the main complain here is that this post is more an advertisement, than some actual content that lobsters are usually interested in. We had the same issue some time ago with the ads for https://sr.ht that were advertising new features.

                                                                        Of course some people follow this project, support it, and are thus interested in every single update, and there is a feed for that. Lobste.rs is a link aggregation platform, not a changelog.

                                                                      2. 3

                                                                        This version has a bunch of new features but anyways it’s the last call to the campaign.

                                                                        1. 5

                                                                          I’d say you’re basically spamming lobste.rs at this point.

                                                                          https://lobste.rs/s/pm4nb7/next_browser_1_3_0_programmable_web https://lobste.rs/s/bvzckk/next_browser_1_3_1_improved_minibuffer https://lobste.rs/s/mjk3j8/next_browser_1_3_3_multiple_selection#c_eawadi

                                                                          Those are all the articles you’ve ever submitted here (with your username.)

                                                                          Looking at your comment history, you only participate in discussions on lobste.rs related to the articles you’ve posted advertising your browser.

                                                                          1. -1

                                                                            you only participate in discussions on lobste.rs related to the articles you’ve posted advertising your browser.

                                                                            There’s one exception :) I started to use Lobsters. But yeah, that’s the end of spamming. The next articles will be from a user perspective!

                                                                      1. 1

                                                                        I would love to be able to try this out on macOS without installing MacPorts or building from source. Are there any plans to offer a prebuilt application bundle at some point? (Or to create a Nix derivation? I noticed there’s a Guix derivation, so maybe that could be adapted to work under Nix+macOS too?)

                                                                        1. 2

                                                                          There’s a nix derivation: nix-env --install next (see readme, no idea how it goes on macOS).

                                                                          Next is also coming into Alpine linux and thus to a Docker container: https://github.com/alpinelinux/aports/pull/11731 (https://github.com/atlas-engineer/next/issues/338)

                                                                          You could also try the pyinstall binary, supposed to be cross-platform: https://github.com/atlas-engineer/next/issues/275 (needs tests and an update though)

                                                                          Thanks for any feedback!

                                                                          1. 1

                                                                            Ah, thanks. It looks like the Nix derivation uses the GTK frontend and so it isn’t usable as-is on macOS.

                                                                        1. 2
                                                                          • Les Amnésiques, Géraldine Schwarz: how ordinary people like her grand-parents helped and participated in nazi’s rise in “going with the flow”. A good read, but a bit short for the topic. Most of it is history. A third on the difference of memorial work conducted in european conutries. A quarter about present politics, which is shit and shows her “bourgeois” origins (I’m not the only one saying).
                                                                          • just started Zomia - or, the art of not being governed, by James C. Scott. Looks like a good and thorough revision of our idea that “societies without state” were salvages and a step towards our full-state civilisation, by studying an enormous region of hills and mountains in asia -the new called Zomia: Zo: out, Mi: mountain, in many asian dialects. No, his thesis is that they did choose to not be part of the states of the valleys (bringing slavery, taxes, wars etc along the settlement) and adopted a political organization and a culture to not be governed.
                                                                          • also started the Little Typer.