1. 3

    I like the idea, but it’s a little too whitespace-y to be called brutalist IMO. If it could fit more toots on a page, I’d definitely use it.

    1. 1

      That could be arranged – page size in the mastodon API is configurable. (Maybe it could even be configured along with the theme.)

    1. 3

      Wow.

      Yeah, I’ve also ended up toying around with Firefox because it sucks so much by default: https://is.gd/iHRkw2. Also got rid of that retarded hamburger menu in favor of Alt/F10 for the normal one, and learnt that Alt+Home fully replaces the home button, so that went away as well.

      They broke Pentadactyl with WebExtensions–the addon installed its own minimalistic UI–and Chromium still sucks a lot more, so I didn’t have much of an option besides QuteBrowser, which I had to leave because of other problems.

      You get what you pay for.

      1. 5

        qutebrowser dev here - out of curiousity, what other problems? :)

        1. 3

          Man, why can’t I rant without repercussions.

          My log tells me I switched 11 June this year but my memory fails to provide context. IRC logs come up empty.

          Let me dig… lack of a good AdBlock (such as uBlock Origin) was one thing. I think I also needed Firefox for some sites, and ran two browsers at the same time often. I think Google had a glitch with default focus.

          Your blog is down as of right now.

          1. 3

            Sorry, blame F5Bot :D

            I still plan to look into a more sophisticated adblocker, but as always, there’s a lot to do…

            Your blog is down as of right now.

            Huh? https://blog.qutebrowser.org/ works fine here.

            1. 1

              It definitely doesn’t work here, might be CDN issues, or I don’t know what.

              1. 1

                What does “doesn’t work” mean precisely? No CDN, so that’s weird.

                1. 1

                  $ ping blog.qutebrowser.org

                  gives me no responses from the Czech republic (residential or VPS).

                  Edit: Okay, it is up now. Wasn’t before.

                  Edit: And now it’s not, again.

        2. 1

          I’ve also ended up toying around with Firefox because it sucks so much by default: https://is.gd/iHRkw2.

          Glad to see I’m not the only one that tries to yank all of the whitespace and unused widgets out. I don’t think interfaces designed to compromise between traditional and touchscreen interfaces work well for either.

          I used to use a Vim-like addon with Firefox many years ago. It was amazing. Hitting ‘f’ to make all of the links keyboard-navigable was the biggest boon, especially with a touchpad, as it meant I didn’t have to fear misclicking with the thing all the time.

          Sad to see addons getting so strangled. Let’s hope things get back to where they were sooner rather than later.

          EDIT: Ah, the hamburger menu. One of the things that I have to help everyone use because no-one has a clue what it does. A good user interface does not hide things, a menu bar is a very discoverable solution that has been around for decades. It’s a shame to see it being pushed aside.

          1. 1

            Not sure what problems you ran into, but I regularly use it as a “focus mode” browser. Light resource usage (particularly since I disable JS with it), and minimal vertical space is great for reading docs/blog posts. I still have FF for sites that don’t support qutebrowser well, but I’m finding most thing work fine in it.

            1. 1

              Now that you touch the topic, I need integrated reader mode, and something to change text to proper black color. The web is a hostile environment. I wish removing all the awful CSS was a reliably solvable problem.

              1. 1

                wish removing all the awful CSS was a reliably solvable problem

                What do you mean by this? Are you referring to the difficulty of doing it in the webextensions environment of Firefox, or the difficulty of partially stripping CSS using heuristic-like things?

                1. 1

                  I’m concerned about stripping (more precisely unifying) formatting while keeping a workable page layout, which, as far as I can tell, can only rely on heuristics. I’m glad that Reader Mode in Firefox at least mostly processes article-like pages successfully.

          1. 3

            Haven’t posted recently, but I might pick it up again soon. Mostly post about compilers, linux, and gamedev: http://charliethe.ninja/

            1. 2

              I get that we’re supposed to keep original titles but I’d argue that the spacing is a result of the site’s “styling” and doesn’t have to be reproduced (just like we wouldn’t prepend a # to every submission’s title that links to a markdown doc)

              1. 2

                In Swedish typography this is called “spärrning”, from the German Sperrsatz.

                https://en.wikipedia.org/wiki/Emphasis_(typography)#Letter_spacing

                It’s basically the only emphasis you have available if you can’t underline or use italics/bold.

                1. 1

                  Yeah, I agree. The spaces just make things like searching for the article harder.

                1. 4

                  Don’t use N computers when 1 will do.

                  This is so important, because people seem to forget that computers are fast. Really fast. Absolutely, mind-mindbogglingly fast. CPUs operate on a level of granularity of billionths of a second, while humans can barely sense thousandths of a second.

                  The only reason computers are “slow” is because most software is crap. I mostly blame Windows and the Web, since they’ve mislead average computer users into believing they have to wait for bloat to run (rather than regularly shouting at developers to profile their code).

                  An average laptop running F-Stack and a decent web server could host a website and handle millions of concurrent requests per second. Distributed systems on AWS are nice and all, but they’re way harder to build than systems that run on a single server. And they’re far harder to profile and optimize.

                  /rant

                  Out of curiosity, I wonder how the author managed to handle concurrency in SQLite, since it locks the whole DB on writes. He mentions writing multiple SQLite databases, but I’d be interested in more details.

                  1. 1

                    Hmm, not come across F-Stack before. Ironic, in the context of your rant, that opening their page showed me nothing but a loading animation for a few seconds :P

                    1. 1

                      Out of curiosity, I wonder how the author managed to handle concurrency in SQLite, since it locks the whole DB on writes. He mentions writing multiple SQLite databases, but I’d be interested in more details.

                      He also mentions using a nifty new (first appeared in 2010 :)) SQLite feature called WAL (Write-Ahead Logging). It makes writers and readers not block each other, plus it makes writes so fast (essentially just an append to a log) that they very rarely block each other.

                      I’m not sure why it’s not on by default, but that’s probably just standard SQLite conservatism in practice.

                      https://www.sqlite.org/wal.html

                    1. 3

                      Ugh… I know it’s not the point of the article but still hurts me to see sql that’s vulnerable to injections.

                      1. 1

                        Ah you’re right. Fixed it.

                      1. 3

                        It’s fast. This solution has the potential to be lightning fast. There are some additional optimizations to take into account, which are explained in detail here

                        the link was dead - here’s a backup: https://web.archive.org/web/20171109151832/http://www.catch22.net/tuts/piece-chains

                        1. 2

                          raco exe + chez will be wonderful!

                          1. 1

                            what’s the advantage in having that?

                            1. 1

                              Chez has a better compiler than Racket. It’s faster, and has a simpler architecture (from what I can tell). Some more details here: https://blog.racket-lang.org/2018/01/racket-on-chez-status.html

                              1. 1

                                Have you tried compiling chez in a repeatable manner, that is delivered as an executable? I got stuck for quite a while dealing with all their boot files - raco exe working would mean I don’t need to do that.

                            1. 6

                              Since I’m graduated, I have loads of free time now before starting my new job in a few weeks :)

                              As an exercise to learn D, I’ve been working on reimplementing MPD in D (https://github.com/charles-l/mop). I am really liking it so far - I feel far more secure in the correctness of my code than with C or C++, and the compile-time code generation is the most flexible I’ve seen for a systems-level language.

                              I’m writing some bindings for the Zumo 32u4 robot for microscheme (https://github.com/charles-l/zumo-32u4-ms), and hoping to get most of the sensors working this week.

                              Also, I’ve been messing around with J, hoping to learn it well enough to use it sort of as a desktop calculator on steriods for writing throwaway scripts. I wrote a Kalman filter with J last week, and will probably write an Extended Kalman filter or something similar this week.

                              I’ll probably also work a bit more on my graphics engine (https://github.com/charles-l/ugg) and possibly a new language project.

                              1. 3

                                All of that sounds really cool. :) On desktop calculator, anyone interested in calculators mixed with programming should check out Frink. It’s a neat, little project.

                                1. 2

                                  Neat - I’ll definitely check out Frink if only because its unit conversion is really nice :)

                                  1. 1

                                    That’s the main reason I kept it. I was thinking having common units in mainstream languages would be a good idea. Frink would be a reference if I ever tried to add it to my own.

                                    1. 2

                                      Here are a few other languages with support for units of measure:
                                      F#
                                      Swift

                              1. 3

                                Very cool - I really like lower-power equipment like this. However, I think it’s a terrible idea for security since it looks like its an unencrypted video stream which would make eavsdropping trivial.

                                1. 6

                                  I’d hesitate to call it eavesdropping if you have to get within 8 ft of the camera to do it

                                  1. 3

                                    It’s sort of the digital equivalent of corner mirrors in stores and on streets.

                                    1. 0

                                      Well that just about kills most of the uses for this product :/

                                      1. 3

                                        No? It’s perfect for home security cameras or on-body cameras.

                                        Sign me up.

                                    1. 3

                                      Did some work on my graphics engine. Added proper FPS camera (still not entirely sure why my code works - I can’t find a clear explanation as to why my view matrix isn’t storing the world coordinates of the camera in the fourth column - I think I’m doing something wrong, but it still works), and basic texturing support (ugly screenshot) this weekend. Going to add a proper lighting model, work on shadows, and refactor the code a bit next weekend. That’ll all probably push me towards adding global illumination and volumetrics for the pretty lighting effects.

                                      Don’t want to get too bogged down in those details though, otherwise I’ll never actually write a game :P

                                      For school, I worked on writing a 2D robot simulator that models a differential drive robot that I’ll be using for the final project in my Robotics class (https://github.com/charles-l/robsim). Good practice for using my linalg skills.

                                      1. 2

                                        I don’t agree with this article. Besides the point about the big distros getting all the support (which is bad). It doesn’t affect me as much, since I use a niche distro (Void Linux FTW!). I’ve happily been running Linux for the past 5 years (which is slightly past the date range of this article…)

                                        I can’t think of one experience where I couldn’t build an old version of software I needed on Linux. If the project has a makefile, I have full confidence that I’ll be able to make && make install without trouble.

                                        Granted, most of the software I run is CLI based, but this it’s still true for all the graphical applications I run.

                                        While I don’t use Windows (at all) and rarely touch my Mac, I can’t really say the experience is as good with them. Some of my friends have found the Wine runs old Windows software better than Windows does (ironic, considiering that Linux is a better Windows than Windows). And the reason I switched from Mac to Linux was because the development experience was being crapped on with every update.

                                        This does all come from the perspective of a developer, but I still use it as a desktop user and would be restricted if I had to use OSX.

                                        1. 7

                                          Have been learning x86_64 asm for a couple of projects I have. I hope I’ll get my e-ink screens this week to start trying to make them refresh fast for a e-ink laptop project I’m working on.

                                          I’ve been also building my jekyll blog to release a couple of write-ups later this week.

                                          1. 1

                                            Which e-ink screens? I haven’t seen anything that was particularly hacker-friendly when I’ve looked in the past.

                                            1. 2

                                              I went with these ones: https://www.waveshare.com/wiki/7.5inch_e-Paper_HAT Following the work from @ninjatrappeur

                                              1. 1

                                                Neat - thanks for the link.

                                          1. 7

                                            I’m currently trying to hack together some sort of text editor, and learn some ClojureScript.

                                            I’m embedding and forking Servo to render stuff, with NeoVim running as a daemon. I don’t really know if it will actually get anywhere, but it’s definitely an interesting learning experience.

                                            1. 1

                                              How easy is it to embed Servo? I’m curious since I haven’t seen any web browsers based on it yet, besides FF. Everything still seems to be Chrome based.

                                              1. 1

                                                It’s… interesting. It wasn’t actually that difficult, just not amazingly documented. The documentation that was there is a little outdated* and I had to figure it out. The main issue is just that it’s changing really quickly at the moment.

                                                I’d definitely recommend having a go if you want, but I wouldn’t call it production ready.

                                                *: I am planning on making a PR when I get the time!

                                                1. 2

                                                  Interesting - that explains why I haven’t seen it used. Hoping the embedding gets better soon - I’d like to see servo in something like QuteBrowser.

                                            1. 3

                                              Finishing off my senior thesis thing on PL implementation (http://github.com/charles-l/capstone), and planning to delve into more graphics stuff this coming weekend. So far I have basic Racket bindings for mesh loading, shader loading, basic (hacky) keyboard/mouse input, and an FPS camera (demo). Still have a long way to go before the dern thing is actually usable, but I’ll start dog-fooding it once I have textures, physics, and some basic audio code working.

                                              1. 5

                                                Huh - this might be enough to make me give D a serious shot. Having to write binding code for something that’s roughly at the same level (i.e. its a low-level language, not a scripting layer - which I don’t mind writing bindings for) always seemed odd for me.

                                                I write C++ like C anyway without much use of templates, so this would work perfectly for me.

                                                1. 1

                                                  Uggg - this sucks. Twitterific is the only way I read Twitter anymore. The Twitter website and official app are trash - I can’t use them ’cause they stick so much unrelated junk in my notifications and timelines.

                                                    1. 2

                                                      Also http://andykeep.com/pubs/dissertation.pdf

                                                      I’ve been using this for my senior project for compilers, and it’s been quite nice. I really like how it does verification of your IR at each pass (really helps debugging), and how declarative each transformation is.

                                                    1. 7

                                                      But a lot fewer people think holistically in terms of writing an application in “Python + C”.

                                                      This is actually my preferred development style now. For some recent work, I was using Python for quick iteration, and an inital prototyping, then I profiled it, found the slow sections in the code, and rewrote those in C++ called through the FFI. I initially wrote the project in C++, but after rewriting it in Python with a few utility functions written in C++ I found it much easier to maintain and debug. I rarely hit segfaults anymore :)

                                                      Unfortunately, it’s probably not especially common that C is the engineering language you want

                                                      I’ve been thinking about this a lot recently. My prefered combo would be Scheme (for wizardry) + SML (for engineering) + C (for speed/low-level control), but there doesn’t seem to be an easy way combine these languages currently. Sure, there are implementations for each of these languages that emit LLVM bitcode, so I guess you could make it all play nice at the LLVM bitcode level. However, a functional IR at a higher level (i.e. a typed lambda calculus IR that could be targeted by functional languages), would be extremely nice since things like types wouldn’t be lost. I’m working on a project for this right now, but I’m not sure how well it’ll turn out.

                                                      Another interesting combination is described in Out of the Tar Pit. The authors suggest a functional language paired with a relational database. I think this model is very interesting and plan to try it with game development (using a custom lightweight in-memory database) with the goal of being as performant as possible (which should be easy since it’s a very data-driven model). This idea isn’t really new - it’s partially what Rails does already, which is why it can scale to larger projects successfully. The database is an engineering tool that handles typing.

                                                      Finally, I really like Racket’s ability to combine languages together in the same project. You can have two different modules in one project, one with Typed Racket and one with regular Racket (i.e. dynamically typed), and the two languages will happily interop with each other. To be honest, I haven’t really had a reason to do this in any of my non-trival Racket projects yet, but from what I’ve experiment with, it seems to work well.

                                                      1. 5

                                                        Terra Language seems like an interesting mixed language approach. High level Lua code and low level C-like Terra code can be mixed, with the Lua code being able to generate Terra for macro type purposes. One could write most of the system in Lua, dropping down to Terra for speed and mix and match as needed.

                                                        1. 5

                                                          If you combine Python and C++, you might find Nim interesting. It’s a language with Python-like syntax that compiles to C with low-latency GC (several actually). You might still prefer C++ for something requiring performance advantages of its abstractions. Given all the Python-to-Go conversions, there’s likely a set of apps you’d write where Nim’s performance alone would be fine. From there, you might either use C++ for the rest or see what of its abstractions you can port over to Nim to retain benefits of Python-like style. The times I’ve seen Racket or Haskell used for things like C++ metaprogramming tell me there’s probably some value for Python/C++ programmers in doing C++ within Python-like language.

                                                          Just a brainstorming aloud here. :)

                                                          Edit to add: I wrote that comment reading your first paragraph. Then I see you bring up Racket. Maybe I wouldn’t have to sell you on benefits of mocking up a system language in a macro language after all.

                                                          1. 4

                                                            In my experience with FFI (at least in Python, with ctypes or cffi), crossing the boundary between the languages is very costly. In libparsing, which uses a C core and a Python module, 90% of the time is spend wrapping match objects from C to Python. This is arguably an edge case given the fact that parsers do generate a ton of data (the match nodes and the AST).

                                                            1. 4

                                                              Painfully true. It’s why both OpenVMS calling standard and Microsoft’s CLR were brilliant in standardizing that part across languages. Then, one can use the right tool for the job mixing them up as needed. That most hardware and compilers are optimized for C means its data types, calling conventions, etc are my default recommendation for this compatibility layer now regardless of what’s technically superior. If it’s possible: sometimes clean-slate stuff that’s not compatible actually gets adoption. Principle also applies to other massively-deployed runtimes like .NET, JVM, Apple Objective-C, or Android ART.

                                                              In some cases, a subset of a massively-deployed language becomes this layer like we’ve seen with Javascript. One I eyeballed for that recently was Go language due to all the articles griping about it. The solution would be some language fixing its shortcomings while totally plugging into its ecosystem with zero-cost integration. That might get a good response. Last popular one with low barrier-to-entry I looked into assuring was PHP. Turns out Quercus beat me to general concept by re-implementing it in Java with access to Java libraries. Still possible to redo something like it or Python in Nim supporting a mix of better-via-new-lang components and legacy-stuff-gradually-rewritten-or-enhanced.

                                                              1. 3

                                                                JavaScript was indeed a promising candidate, with a highly optimized runtime, composite data types and prototypical inheritance. If only the steering committee of that language decided that instead of adding more features and make it look like Java or C#, they should focus on adding core primitives to make it faster (typing, pragma-like compiler hints), then we would have a pretty good candidate for a runtime on which to quickly build a wide range of languages. I’m sure that if we looked at the languages which are used as a base for other languages, JavaScript would come just after C, or maybe even first!

                                                              2. 1

                                                                I never really measured the cost of jumping back and forth between Python and C, but I’m sure it’s horrible. It’s fine for me because I tend to have the C code do a significant amount of processing before returning back into Python. Python type conversions regularly surprise me with how expensive they are, but I guess that’s because Python is the only language I pay close attention to for performance issues (since the problems I tend to solve with it are computationally expensive).

                                                                1. 1

                                                                  And also if you try different runtimes like Py2, Py3 or PyPy you’ll see how things are handled differently. PyPy for instance has a tendency to reallocate strings, which forces you to copy string values from Python to C. I came to a point where I considered making the C library spit out a string representation of the matches to be parsed by Python. I did not do it, but I bet the performance might not be too different, maybe even better!

                                                            1. 15

                                                              C++ got its act together. Java and Perl came along (and later, Python). Meanwhile, Lisp hadn’t advanced much in about a decade (since the ANSI spec was finalized). It was still a win, but the competition had narrowed the field. Once upon a time Lisp had a long list of features that no other language had (GC, full numeric tower, CLOS, incremental development, macros) that list kept getting shorter and shorter, and the case for Lisp, which had never been easy even in the best of times, was getting harder and harder to make.

                                                              I think that this is definitely an issue with Lisp. The core is really, really good; it still has plenty of features that common languages don’t have. But even though it’s more advanced than they are, it’s still stuck in 1994. The median language is a lot better in 2018 than it was in 1994: it’s JavaScript, which is a horrible, terrible, no-good language but still orders of magnitude better than C for software development.

                                                              Lisp is still better: it still has things JavaScript, Python, Java, Ruby, Scala, Erlang & Go are all missing. But it’s not as much better as it used to be, because all of those languages are much more capable than C, assembler & Pascal.

                                                              But then a very strange thing happened: I noticed that all around me people were writing code using C++ and Java and Python and even (gasp!) Perl, and they were actually getting it to work without tearing their hair out. In fact, in a number of cases I saw people whip things up in Perl in a couple of hours that would have taken me days or weeks to do in Lisp.

                                                              I think that’s a factor of batteries being included. Once upon a time Common Lisp was derided for including hash tables: nowadays they are table stakes. Once upon a time people laughed at Common Lisp for being a huge standard; now they laugh at it for not including a web server, let alone standardising sockets.

                                                              The good news is that this is fixable (we can always have a new standard, if we want to go to the effort), and in practice it more-or-less is fixed: Quicklisp provides semi-standard libraries for everything. Would it be nice to have a truly-standardised library equivalent to, say, Go’s? Hell yes. Can we get by with what we have now? Sure.

                                                              I do think that the Lisp world needs to consider a compatibility-breaking Common Lisp 2 at some point. The world has changed a lot in 24 years; it’s time Lisp took note.

                                                              1. 9

                                                                What do you think of other newer age Lisps like Clojure?

                                                                1. 9

                                                                  Honestly, I don’t like Clojure — it’s not (IMHO) really a Lisp (among other things, it breaks conses). It’s a neat language, but it’s not my cup of tea. I’d like to see a Lisp continued & carried on, not a break with tradition.

                                                                  1. 8

                                                                    cons, car, cdr is the least that I miss in clojure, I guess they are a bit too low-level for my taste (and kind of complicated for reading code, although I never had a problem writing them out for some reason).

                                                                    What I kind of miss is in Clojure is CLOS, i.e. a multiple dispatch object system.

                                                                    1. 3

                                                                      I am not familiar with CLOS, but Clojure does have this.

                                                                      1. 1

                                                                        Yes, and if it hadn’t this, one could probably write a multiple dispatch system with macros. I guess i could build my own island of multi methods. But that is a little different from an ecosystem that invests in them like Dylan or cl.

                                                                        1. 1

                                                                          I’ve been meaning to try Common Lisp. Things like the condition system, image dumping, CLOS, and MOP seem different from what I know and worth learning. I’m going to try out PAIP. Any insight on what the CL ecosystem tends to do with mutli-dispatch?

                                                                          1. 2

                                                                            I might be the wrong person to ask, because I never really used it (CL, and multiple dispatch) for more than a few example programs. First of all it implements OO in a way that nicely fits into the lisp functional programming world, i.e. procedures/functions first. Then there are the instances were you’d normally resort to the visitor pattern and can use multiple dispatch for truely polymorphic functions. I think they aren’t as widespread as one might think, but every now and then, multiple dispatch really helps at keeping code simple.

                                                                  2. 8

                                                                    You beat me to it. Ill go straight to saying it seems to solve that very problem with proof being its mainstream status having a big community and plenty of job ads for it. Need more LISP initiatives like that.

                                                                  3. 8

                                                                    I do think that the Lisp world needs to consider a compatibility-breaking Common Lisp 2 at some point.

                                                                    i’d love to see that effort put into optimising the racket runtime and adding libraries to it, personally. i think it has real potential to be an “industrial-strength” langage; the design is already excellent.

                                                                    1. 6

                                                                      i’d love to see that effort put into optimising the racket runtime and adding libraries to it

                                                                      Some work is being done right now to integrate the Chez scheme backend with Racket, which would mean some really nice speed improvements for compiled code.

                                                                      1. 3

                                                                        The problem with Racket is that it’s very much a Scheme rather than Lisp, with all the mistakes that come with being a Scheme: Lisp-1, #f, (car '()) being an error. It’s an incredibly impressive body of work, but I wish that effort had been expended on Common Lisp instead.

                                                                        1. 8

                                                                          wait why shouldn’t that be an error though.

                                                                          1. 4

                                                                            wait why shouldn’t that be an error though.

                                                                            Because it makes writing code which walks through lists a bit simpler. It’s useful that (car nil)nil & (cdr nil)nil. This — like having multiple namespaces — is one of the places where Lisp is more pragmatic than Scheme. I find that quality attractive in a programming language meant to be used.

                                                                            I really wish that I could find a good article about this to share with you. I know that I’ve read one in the past, found the arguments convincing and have had the ‘nil should be carable’ bit set in my head since.

                                                                            1. 7

                                                                              It’s useful that (car nil) → nil & (cdr nil) → nil.

                                                                              That sounds horrible, a recipe for “foo is not a property of undefined”-style errors miles away from where the problem actually occurred. Surely your functions should know what kind of data they expect to be operating on, and fail-fast is not.

                                                                              1. 3

                                                                                Yes that is my view too. Though I think for smal projects bargap’s proposal could be good but as the project grows in size the need for errors to happen close to the source of the problem grows.

                                                                                1. 1

                                                                                  It actually works out very well with the sort of code which is written in Lisp. Typically, Lisp systems depend on it.

                                                                                  1. 2

                                                                                    I’ve found it to be the single largest source of errors in the lisp systems I work with.

                                                                                    1. 1

                                                                                      Are you writing Lisp or Scheme? If you’re finding it to be a huge source of errors in Scheme, then wouldn’t that tend to support the Common Lisp way of doing things?

                                                                                      1. 3

                                                                                        I mostly write Clojure and Emacs Lisp, (since 2008 and 2004 respectively) which use nil in the same way Common Lisp does. I don’t have these problems when I write Racket.

                                                                                        1. 1

                                                                                          I don’t know Clojure, but I’ll agree elisp is a good basis for comparison. All I can say is that my experience with elisp & Common Lisp differs from your own, and that my experience with Scheme has convinced me that I do not want to write a large system in it — nor use a large system written in it.

                                                                                2. 6

                                                                                  Leaving nil out of the language is hands-down my favorite thing about Racket. So many of the problems of CL and Clojure just evaporate completely.

                                                                                  1. 6

                                                                                    Of course Racket has nil. It’s just written '().

                                                                                    1. 7

                                                                                      When I say nil here I’m referring to a single value which can mean “emptiness”, “false”, or “not found” depending on the context. Racket has three different values for each of those cases instead of lumping them all into a single value, and that is much less error-prone.

                                                                                  2. 2

                                                                                    Could you write a car that doesn’t error, Call it care

                                                                            2. 3

                                                                              That reference to Quicklisp made me think about slib

                                                                              I like the idea of having a standard library build only on spec scheme and app’s built with the specific particularities of scheme implementations.