643 karma · joined April 29, 2022
Of course, there are constructs such as `let` and `cond` that are more parenthetically noisy (not so much in Clojure though), but on the flip side you don’t have to remember a lot of special syntax like in non-lisp languages.
Most Lisp-people also use structural editing tools like paredit[1], which make it really easy to write and edit s-expressions. I found that after some time I didn’t really think that much about parentheses anymore.
[1]: https://paredit.org
Although it seems to catch up with experimental support of React 18 now, Reagent has fallen behind the latest developments in React and may not benefit from all of its performance optimizations. It is still using class components instead of hooks and there have been concerns that the runtime conversion of Hiccup may drag down performance. I guess in most cases it is not really an issue or in any way noticable, so if you’re not doing any fancy stuff it should be fine. I may even come back to Reagent at some point, since I have to admit that I miss the UI-as-data model with Hiccup.
What I highly recommend, however, is using re-frame[2] for state management. It has also been around for a long time (2014, around the same time Reagent came along) and pioneered some popular ideas in that area. It may seem a bit overwhelming at first, but the docs provide a great introduction and I find the model very clear once you wrap your head around it. At the moment it depends on Reagent, but there are ways around that. [3]
[1]: see Helix (https://github.com/lilactown/helix) or UIx (https://github.com/pitch-io/uix)
[2]: https://day8.github.io/re-frame/
[3]: refx (https://github.com/ferdinand-beyer/refx) is an almost drop-in replacement without the Reagent dependency, but hasn’t been updated in a while. Alternatively, re-frame can be integrated with UIx/Helix by adding some interop code https://github.com/pitch-io/uix/blob/master/docs/interop-wit...
I know that there are projects like Lem[2] that try to build some kind of editor (Emacs-like, I guess) on top of CL, which made me wonder if we would have a CL-based Emacs today if it would have been standardized by the time and if this would have been a better choice than creating a custom dialect.
[1]: https://www.gnu.org/software/emacs/manual/html_node/cl/ (C-h R "cl" in Emacs)
I don’t think that from “dull” memorization and mindless practice alone (how it was often done in school) understanding at a deeper level somehow magically happens. What I do believe is that both (“smart”) memorization and explorative/playful interaction with the subject matter (turning it upside down, interrogating it, relating it in different ways, etc.) support each other, which, after some time, creates enough structure in ones neural pathways such that deeper insight can emerge from intuition.
When we try to learn math conceptually, we focus a lot on metaphorical or contextual understanding (“what is this like?”, “how does this apply to the real world?”, etc.), which may divert attention away from the actual subject matter, which is the symbols, formulas, equations, axioms, theorems, diagrams and so on. It is all one really needs to understand.
Sometimes I read texts where the author talks about mathematical ideas in a very vague and abstract language, mystifying and obscuring it or entangling it with other subjects. But then it turns out what they write makes no actual sense in the language of mathematics, which itself is very concrete and clear. Maybe they have fallen into the trap of thinking that they knew about the subject when all they have is a broad conceptual perspective without any grounding in the actual rules of the formal system.
For Org Mode, my main concern is that I want to quickly identify the structure of my documents and differentiate all the relevant parts visually. I like to keep font sizes and spacings small to fit as much text (= context) on my screen as possible. I also like using monospace fonts because it feels more like working on a draft (e.g. with a typewriter) to me and I can work more spatially with text (e.g. making little diagrams or figurative text arrangements) which would not be possible with proportional fonts.
When everything looks too good/refined, I get distracted by wanting to shape my text to make it fit in that perfect environment. Then there is no space for swift notes, unfinished drafts, rough edges and this becomes a problem, since I am already a compulsive perfectionist and like to waste a lot of time with irrelevant details. Of course, this is just my personal preference, so I am not saying that this is how it should be. Maybe I am just trying to understand why I like it better this way.
[1]: https://www.masteringemacs.org/article/fun-games-in-emacs has a list of fun Emacs commands (mostly games) to try
Although I wish they’d explore the Kakoune/Helix style of editing too, which I think will become a major competitor to Vim (and I personally prefer it myself).
However, I am also worried that Lem won’t gain any traction because the Emacs ecosystem is just too vast and has too many killer apps (Magit, OrgMode, Dired, the amazing built-in Help/Documentation - to name a few).
But it may very well become a modern Emacs alternative if they focus on better user experience, leave behind some idiosyncrasies of the past and create great alternatives or ports of Emacs’s most appreciated plugins. There is a great opportunity in starting from scratch, but I guess it is also a huge challenge to compete against decades of development, a huge community and a rich ecosystem.
As someone who is not an expert but tries to gain wisdom from past experiences, it helps me to see where my intuitions might have been right or wrong, even if I may not get the point right away.
The one thing I don’t like is that symex depends on so many other plugins (especially Evil, which I am trying to swap out with the more lightweight meow), but this will apparently change soon. They are also working towards support for non-Lisp languages via tree-sitter, but I don’t know how well it works.
With all the things he has accomplished and his competence across different fields, I don’t mind him being arrogant sometimes. He is working in the area of fundamentals of science, so of course there will be bold claims made - anyone can judge for themself if they hold water.
Science in institutions is often stuck in its entrenched paths and few people dare (or cannot afford) to step outside and try new things, especially across different fields. I believe people like Wolfram, who have earned the knowledge and experience to be able to make a serious attempt on advancing science in new and different ways, are a very valuable resource for humanity, even if they may not succeed.
- [1] https://jkbgames.com/w/index.php/MegaMan_X:_Corrupted_Wiki
I believe it is a disservice to the author and the reader to focus solely on the marketing side of things. After all, the design of the book is part of the product, which, as a whole, sets the frame for the reading experience. Physical books today have to compete with digital content and ebooks, so as a reader I would expect that more effort is being made to make a product that also looks and feels good and not only carries the content to my eyes. That also applies to the layout and typesetting of the inner pages, which is unfortunately often careless and not aligned with the cover design (let alone the choice of paper and binding, which is of course seldom in control of the designer).
I also found a more recent book[2] by George Stiny called “Shapes of Imagination: Calculating in Coleridge's Magical Realm” that is also about shape grammars and is actually open access. Coming from a design background, I am sure to take a closer look at some of this stuff.
- [1] https://web.archive.org/web/20190405160829/http://shapegramm...
- [2] https://direct.mit.edu/books/oa-monograph/5489/Shapes-of-Ima...
Git Tower is actually a great tool, but I believe Gits core concepts cannot be understood well without lots of experiments with the bare Git CLI (what helped me most was making toy repos → testing my hypotheses on how things work → observing/inspecting results).
“And a couple of important consequences:
- You CAN’T determine the length of the string by counting bytes.
- You CAN’T randomly jump into the middle of the string and start reading.
- You CAN’T get a substring by cutting at arbitrary byte offsets. You might cut off part of the character.”
One of the things I had to get used to when learning the programming language Janet is that strings are just plain byte sequences, unaware of any encoding. So when I call `length` on a string of one character that is represented by 2 bytes in UTF-8 (e.g. `ä`), the function returns 2 instead of 1. Similar issues occur when trying to take a substring, as mentioned by the author.
As much as I love the approach Janet took here (it feels clean and simple and works well with their built-in PEGs), it is a bit annoying to work with outside of the ASCII range. Fortunately, there are libraries that can deal with this issue (e.g. https://github.com/andrewchambers/janet-utf8), but I wish they would support conversion to/from UTF-8 out of the box, since I generally like Janet very much.
One interesting thing I learned from the article is that the first byte can always be determined from its prefix. I always wondered how you would recognize/separate a unicode character in a Janet string since it may have 1-4 bytes length, but I guess this is the answer.
Not using Tailwind as much these days (more inclined to CSS-in-JS solutions like Stitches, which unfortunately has been abandoned by the developers), but for prototyping it’s still amazing.
It is natural that this “strategy” would lead to more success in the end, which applies to any kind of challenging activity. I like the description as “subtracting”, since you kind-of have to empty your mind before doing the thing. But I believe this does not apply to practicing, where you do have to make conscious efforts and “add to” yourself a lot of stuff in order to internalize it and hopefully build up the intuition required for this flow state to work.
As some here pointed out, doesn’t have to do anything with self-optimization. Although self-optimization may lead someone to believe that a lot of conscious effort is the key to success, when it can actually set them up for failure.
Those were the projects that I redesigned multiple times, because the previous approach just didn’t “feel right”. I invested a lot of research into that feeling, it was somehow addictive (and sometimes equally frustrating) to me.
As a developer, I now have a similar experience with personal projects that grew out of my own curiosity. When doing something for clients, I often feel myself torn between what feels “right” to me and what the client actually wants or prefers. It may often not be what they really need, and I know that, but this is why I must have my personal projects, because client work often feels unfulfilling to me (however, it is fulfilling in a different way).
The linked website seems to be very nice, especially since there is a community aspect to it, where people can send in their own puzzles (it seems like).
My recent goto app for Nonograms is https://nonograms-katana.com , which works great on browsers and mobile alike with lots of well thought-out features (e.g. it asks you if you want cells automatically crossed out if a line is complete) and beautiful artwork, good interaction, etc.
I might be buying the book if I really like it to support the authors, but it’s great that they made it available for everyone.
I haven’t read the whole article yet, but maybe it could be interesting to compare it with Haskell and see if some of the same problems occur or if Haskells compiler or overall design around (pervasive) lazyness makes it easier to work with and more performant.
It helps me to avoid getting overwhelmed with complexity and, as a nice side-effect, to avoid premature abstraction and optimization. Most of all, it helps me (as mentioned in the article) to actually build something. It is also quite satisfying and motivating to quickly get to a state where your product already works and to build on top of that, making something better that already works.
I used to work like that when I began programming, because I just wanted to solve a problem for myself and put it out there as quickly as possible. I had to re-learn this way of thinking as my ambitions grew and as I wanted to make things “perfect” and be “professional”.
Of course, in this approach lies the danger of accumulating features and complexity, so it is important to keep the focus on the problem or the “essence” of what the product is supposed to be.
The book is amazing, but it is also very extensive/overwhelming and I found that the lectures provide a better guiding structure for myself and the lecturers are also quite entertaining at times. The website also provides additional material related to the course such as exams, projects and lecture notes.
- focus on agent-based modelling (feels more like a DSL to me)
- lexical scoping of local variables and inputs instead of dynamic scoping
- no “word” data type (similar to symbols in Lisp) - instead, NetLogo uses strings in most cases where words would be used in Logo
- control structures (if, while, etc.) are special forms instead of ordinary functions
- NetLogo is a Lisp 1, while Logo has been a Lisp 2 (separate namespaces for values and functions)
See http://ccl.northwestern.edu/netlogo/docs/programming.html#co... for a more detailed comparison.
Despite its educational focus and reputation as a language for children, UCBLogo (a dialect of Logo from 1992 intended for being a “minimum Logo standard”) seems to be quite advanced and also has some “adult” features (partially derived from its Lisp heritage), such as higher-order functions, eval & apply, recursion, anonymous functions (or rather something similar called “templates”) and macros.
However, NetLogo feels more like a modern version of Logo without some of the weird/unfamiliar stuff (like dynamic scoping and words). It is heavily used and taught at https://www.complexityexplorer.org , so if anyone is curious enough I recommend taking a look at their free courses/tutorials such as “Fundamentals of NetLogo” or “Introduction to Agent-Based Modeling” - they are probably the best resources out there to learn NetLogo.
However, I also have many plugins installed, so it might be just that. I wonder if it is possible to install a separate instance of Emacs, then I would be able to test the performance without all the plugins and configuration.