Fogus

I agree that Clojure is continuing to rapidly gain mind share – among long-time Lispers, relative newcomers to programming, and also seasoned "curly bracers" that a few years ago never thought they'd see a day when Lisp would make it into mainstream dev shops. Personally, I like it a lot and use it on a daily basis. The excitement around it is in no small part due to the insightfulness and ongoing hard work of Rich Hickey[1], his close collaborators at Cognitect[2], and some amazingly dedicated community talent (e.g. Philip Hagelberg[3]). Not to be overlooked is the brilliant decision to have it be a "hosted language" that interoperates with non-Clojure code on the JVM with little to no hassle – that opens a lot of doors, better believe it! That being said, I attended RacketCon 2014[4] last Saturday and was blown away by the work going on in that community. Michael Fogus[5], a well-known name in the Clojure community, even gave the keynote[6]. The language's creator, Prof. Matthias Felleisen[7], and his grad students have been doing truly cutting-edge work over the last 18+ years (what became Racket was "conceived" at Rice University in Fall 1995). It's a fair question, though, whether the Racket team even wants the language to "make it big," i.e. along the lines of Clojure's rapid rise in popularity. I got the impression they have mixed feelings about that prospect, and those concerns have certainly shaped (and will shape) their marketing of Racket. My thought is that if,…

via https://blog.fogus.me/2025/12/23/the-best-things-and-stuff-of-2025.htm… via https://news.ycombinator.com/item?id=46365726

Deju Vu... https://blog.fogus.me/2025/12/23/the-best-things-and-stuff-of-2025.htm…

https://blog.fogus.me Programming posts, some gaming talk, and occasional random ramblings.

This is so exciting to see! I became obsessed with Inform7 a while back after I learned about it from "The best things and stuff of 2014" [1]. I remember scouring the web for its source code and being really bummed it wasn't open source. I can't wait to finally dive in! I've never seen a literate program of this scale before. [1] http://blog.fogus.me/2014/12/29/the-best-things-and-stuff-of-2014/

Hiring fogus to work on Clojure sounds great to me. Two thoughts: - I'd love to know if this was enabled by Nubank's purchase of Cognitect. It's none of my business; I'm just curious. - As an enjoyer of the history of programming languages, I'm always going to be glad when anyone who has read their lisp joins the Clojure team. I bought Kogge off fogus's (and Stanislav's) recommendation. http://blog.fogus.me/2012/07/25/some-lisp-books-and-then-some/

I'll see your PG list, and raise you the latest fogus best things and stuff (of 2019) list.[1] 1: http://blog.fogus.me/2019/12/30/the-best-things-and-stuff-of-2019/

Yes, and the BoS forums had something great going as well. The ones from this list at some point were great: http://blog.fogus.me/2011/03/27/the-long-lost-art-of-thoughtfulness-in…

Fogus also makes a nice list of books and other things at the end of each year. http://blog.fogus.me/2015/12/29/the-best-things-and-stuff-of-2015/

This resonates with author's famous blog post about reading [1] In that blog post he recommends reading several books simultaneously and abandoning boring books with no regret. [1] http://blog.fogus.me/2012/02/22/reading/

It came across my radar via Michael Fogus's Six Works of Computer Science-Fiction[0]. After reading the first chapter, the reasons that people love/loved Forth suddenly make sense. Like Lisp it's full stack - from close to the metal to arcane abstractions. [0]: But only after the second time it was posted to HN. http://blog.fogus.me/2015/04/27/six-works-of-computer-science-fiction/

Here's another list sorted by decade. http://blog.fogus.me/2012/09/21/the-amazing-colossal-science-fiction-k… Been following it for a few years now.

Fogus did a similar list of his 2013 bests : http://blog.fogus.me/2013/12/27/the-best-things-and-stuff-of-2013/

On this[1] recent podcast[2] fogus had some amazing insights on Pair Programming, as Relevance also has a pairing policy. [1] http://thinkrelevance.com/blog/2012/03/28/thinkrelevance-the-podcast-e… [2] http://blog.fogus.me/2012/03/29/fogus-on-think-relevance-podcast/

Must keep an eye on this. Blog link here for convenience: http://blog.fogus.me/

I regret I have but one upvote to give to your comment. :) Instead I'll add this: "Whenever I interview a candidate I always work in some variation of a very simple question: 'How would you change your favorite programming language to make it better?' "I don’t really care what the answer is (that is, I don’t mind if we disagree). However, I care very much that people think critically about the tools that they use and love." http://blog.fogus.me/2011/04/26/my-favorite-interview-question/

It is worth noting that there are a few other paradigms that can change the way you think of programming - recently there was a post providing a good overview of languages that will make you learn some new abstractions, functional programming being one of them: http://blog.fogus.me/2011/08/14/perlis-languages/

Yes it can be confusing to a novice how Perl sigils work. Hence Larry Wall conceded this as an issue and so one of the reasons he went for invariant sigils in Perl6. However there is logic in the madness. Perhaps Larry Wall/linguistic logic but none the less it does work! The best explanation i've see is the comment by "Matt S Trout" on devolving-sigils blog post (http://blog.fogus.me/2009/02/26/devolving-sigils/). Below is the key sentence from mst comment: Actually, perl sigils don’t denote variable type – they denote conjugation – $ is ‘the’, @ is ‘these’, % is ‘map of’ or so – variable type is denoted via [] or {}.

This looks like a relatively old paper (2002) and so I think it is measuring performance on strictly single processor machines. On the other hand it is trie based which suggests that it could also be highly parallelizable on modern multi-processor systems. (I am thinking clojure data structures here and maybe the submitter was too... http://fogus.me). Then again maybe datasets of the size tested (or much bigger) are now just broken down in a map-reduce fashion over multiple machines, and then who cares about the efficiencies of cache misses etc? Can anyone comment on if burstsort or trie based sorting algorithms in general have been adopted? (All my experience has been as a consumer of library provided "sort" methods rather than ever looking at current state of the art algorithms).

Devs I think are somewhat withdrawn, as a result of being under the yoke of ticket delivery. Being given the trust respect & capacity to roam & improve as we wander about systems is rare; we're judged on how quickly the task at hand is done. This is such Luddite, chained-to-the-machine endpoint that we are at. And it skips past so much of the raw joy & auto-enrichment loops that happens when there's time allotted to discovering and improving the system as you go. DIYers have such amazing enrichment loops, making systems work better for themselves all the time. Not just the much vaunted fast delivery now, but the ability to keep iterating & expanding & delivering without your constructs starting to clash & thrash. I love love Fogus's 100:10:1, on having many tangible places outlined where one might do something. Still dedicating yourself to something, but also giving yourself permission to hop around. Follow what feels good. https://blog.fogus.me/2015/11/04/the-100101-method-my-approach-to-open… [Ed: s/yolk/yoke/, thanks for the fix folks!]

Ah, thanks for all that, and I will try the new version of gambit. I don't remember for certain whether the looping I encountered was with the old version. It will be cool if Ribbit can become completely self-hosting. I do know there have been some web sites (including I think HN) written in Scheme, that originally used continuations as sessions, but ended up switching away from that approach once things got more complicated. It's a cool idea though. Ribbit reminds me of this article mentioning "Fluchtpunkt Lisps", in case you're not familiar with it: http://blog.fogus.me/2011/05/03/the-german-school-of-lisp-2/ I guess it is an example of one. Ribbit seems more interesting to me than Sectorlisp because of the issues you mention! I'll keep playing with it. Even if I don't find direct uses for it, its implementation methods are worthy of study. I've been wanting for a while to make a Hedgehog Lisp back end for Purescript (purescript.org). Ribbit might be another interesting target. Added: I think the Ribbit REPL needs some kind of exception trap. Otherwise saying something like (3) crashes the whole interpreter, which is not so great for an interactive environment. Hedgehog has built-in functional AVL trees that substitute for hash tables, arrays, and other lookup structures. They are very useful, but are an example of functional style possibly requiring more ram than imperative style where you can mutate stuff.

There have been some fantastic conversations on Hacker News about type systems. I've learned a lot about the different arguments for dynamic typing, versus strict typing, versus gradual typing. Java's type system may or may not have represented new thinking when it was under development in the early 1990s, but it certainly seems a bit dated in the year 2016. The limits of the Java type system have been discussed both here on HackerNews and also elsewhere, many times. For those who want to consider arguments against Java's style of strict typing, 2 things I would recommend include "Agility & Robustness: Clojure spec, by Stuart Halloway": https://www.youtube.com/watch?v=VNTQ-M_uSo8 He offers a chart that shows the strengths and weaknesses of strict typing versus unit tests versus the run-time checks offered by Spec. It's worth a look. The discussions around gradual typing have been interesting, but to see how far the limits of this can be pushed, I would suggest everyone check out the Qi/Shen programming language: https://en.wikipedia.org/wiki/Qi_(programming_language) "Qi makes use of the logical notation of sequent calculus to define types. This type notation, under Qi’s interpretation, is actually a Turing complete language in its own right. This notation allows Qi to assign extensible type systems to Common Lisp libraries and is thought of as an extremely powerful feature of the language." This next quote is from someone who has spent a long time experimenting with…

I love Fogus's take on 100:10:1. As opposed to this highly linear ever-winnowing flow, Fogus uses 100:10:1 as a way to keep a list of spitballed ideas, a list of things he might want to work on that all have sincere promise, and one thing picked to focus on. Instead of being process driven, focusing on getting one thing done well, Fogus lets himself switch among his 10 picked items. The 10 is a way to swap out when interest wanes. 100:10:1, my approach to open source- http://blog.fogus.me/2015/11/04/the-100101-method-my-approach-to-open-… This process speaks to me a ton (a whole lot more than Nick's rigorous phased development process). When my attention and care for an interesting, creative project wanes, I can either dig in my heels and try to make myself code, or preferably I can switch to some other promising piece of development. Having a deck of other ideas decreases the context switch time- when a project is in a lul, there's already other great gems prepped, and one of them can re-inspire me. Quite the contrast. I wonder how much of it is due to Fogus's focus on developing open source software, versus Nick' focus working on physical board games.

I love Clojure, and I use it in every project where I have control over the technology, but I do agree with the points raised by Ashton Kemerling. Clojure is beautiful, and backed by beautiful theories, but its implementation needs to be clean or it will eventually develop enough special cases that its beauty will be ruined. In some sense, you could say this is what happened to Ruby, though there the allowance of "special cases" was more deliberate. I recall, back in 2003, reading the interview between Matsumoto and Bill Venners: http://www.artima.com/intv/ruby.html -- and I thought that Ruby had a beautiful philosophy. But having worked with Ruby for many years, I now see how much it is undermined by the many special cases it allows, and the wild ambushes that its most imaginative features allow (monkey patching). I don't want to see Clojure go down that path. I want Clojure to remain beautiful, and that means the implementations must also be beautiful. There is a limit on how much the core team can say "That bug is only an implementation detail". If you take away all the implementation details, then Clojure is only a theory, not a real technology that can be used by real people to do real things. In a truly ideal world, Clojure could be the practical Lisp that pushes itself to bring in as much of the experimental Lisp's beauty as is practical. I would love to see the best ideas from Racket and what Fogus refers to as the Fluchtpunkt…

tl;dr - you don't need to care, you can do perfectly well without it, but you're missing something. Longer answer ... There are several issues here, and many people conflate them. They are realted, and I'm not going to be able to do them justice in a quick reply here. It's Christmas Eve, and I have a lot to do. So, briefly ... Learning FP, really learning it, gives you a new insight into programming. It can change the way you work, and the way you think. If nothing else, it's mind expanding, and that's always a good thing. There's a seminal paper "Why Functional Programming Matters"[0] (WFPM). It dates back to 1984, but it's still relevant. In fact it's so relevant that raganwald[1] wrote "Why Why Functional Programming Matters Matters." That's also a really good read, with many useful insights. fogus[2] has included WFPM in his list of 10 technical papers every programmer should read twice.[3] There's also a StackOverflow discussion[4], probably several. There are many, many programmers out there, capable, productive, useful programmers getting stuff done, but knowing nothing (significant) about FP. And that's fine. But personally, I think that if you want to be serious about your craft, you should learn about FP, what it is, what it's good for, how to think in it, when to use it, and when to avoid it. It's not the One True Style(tm), but it is [0] http://www.cse.chalmers.se/~rjmh/Papers/whyfp.html [1]…

fogus has a couple of nice little posts on the threading macro itself... https://blog.fogus.me/2013/09/04/a-ha-ha-ha-aah.html https://blog.fogus.me/2009/09/04/understanding-the-clojure-macro.html

I made a video about some of the benefits of using ClojureScript for developing VS Code Extensions. It's a short (9 minutes) demo of me hacking on an extension of mine, trying to relay what it is we Clojure peeps mean when we speak of Interactive Programming (aka REPL Driven Development). I find it super powerful when hacking on extensions, since restarting the Dev Extension Host can be pretty disruptive. And having to halt the program in the debugger to inspect it often does does not fit when searching for the cause of a problem. This article on LISP interactivity inspired me: http://blog.fogus.me/2022/11/10/the-one-about-lisp-interactivity/

A list of this exact kind of books is presented here: https://blog.fogus.me/2015/04/27/six-works-of-computer-science-fiction…

Here's the largish summary about the discussions from 9 years ago, that found the applications limited and tradeoffs painful: http://blog.fogus.me/2011/10/14/why-clojure-doesnt-need-invokedynamic-…

That link seems to be here: http://blog.fogus.me/2011/05/03/the-german-school-of-lisp-2/ Which was discussed here: https://news.ycombinator.com/item?id=2509696