sahil-kang

or perhaps it'll go down the QUIC path instead :)

context: QUIC was originally an acronym as well

I haven't seen it implemented anywhere, but that sounds like the "pagetable displacement" approach described here: https://wiki.osdev.org/IPC_Data_Copying_methods#Pagetable_di...

The same idea occurred to me a while ago too, which is how I originally found that link :)

fwiw, I normally think of LMDB when the idea of using the fs instead of a db crosses my mind

If I was to tackle a simplified view of the problem I think you're describing: your frontend devs should provide the markup template the backend would interpolate and return

In the scenario you've alluded to, your backend devs are currently producing json data and your frontend devs are interpolating that into markup in the browser. In the simplest case then, your frontend devs would just provide a markup template that can be interpolated with the json already being produced. In slightly less simple cases, they can provide a function to be called instead

The gist is that the logic of taking data and producing markup should remain in the frontend dev's wheelhouse

I think this htmx essay [1] addresses the tradeoffs you may be getting at if you're thinking "why html vs js+json": the gist is that html is self-describing to the browser, so the backend can make changes to the html it produces and the browser will understand it without the frontend code needing to be updated

If you're instead thinking more broadly in terms of "structure vs layout", I think the same reasoning for using something like tailwind css or higher-level web components may apply: i.e. the material you interact with is closer to your problem domain

[1] https://htmx.org/essays/two-approaches-to-decoupling/

If I understand correctly, the main selling point of htmx is that _html_ is extended with the attributes from GP: the idea being that a bulk of the interactivity of SPAs can be achieved via hypertext alone

I think a more precise reading of GP's "changes just 4 things in browser behavior" is "changes just 4 things in html behavior"

I can understand the failure to build a critical mass of contributors, but can you share some examples of where your work was duplicated instead of built upon?

I’ve read through some of your async work in the past and from an initial glance, it seemed like you had the right idea by wrapping existing event libs and exposing familiar event loop idioms. At the very least, it seemed uncontroversial so I’m interested to see why others would choose not to build upon it.

If you found this interesting and want more, then I think this is a good follow up to read next [1]. It takes a similar approach to introducing the code-as-data idea, but uses xml instead of json as an introductory structure.

[1] http://www.defmacro.org/ramblings/lisp.html

I think the kind of licensing you’re referring to is usually called permissive licensing [1]

[1] https://en.wikipedia.org/wiki/Permissive_software_license

Here are some examples showing Common Lisp’s built-in support for multidimensional arrays: https://lispcookbook.github.io/cl-cookbook/arrays.html

Can you share more info about the parentheses being a hazing test? I’ve seen Dylan syntax [1], but is there something else that shows the parentheses to be unnecessary in 2020?

[1] https://en.wikipedia.org/wiki/Dylan_(programming_language)

Yes, the kernel does remove unmaintained/unused code according to GKH at 30:30 in this interview [1].

[1] https://youtube.com/watch?t=1830&v=t9MjGziRw-c

I think you can draw this ‘core of an environment’ parallel between Forth and Scheme: both are small languages and they emphasize growing the language to the problem domain [1]. Common Lisp, on the other hand, is a large language: implementations provide much more than a foundational core, and a fairly comprehensive list of libraries exists. I think RPG’s Worse Is Better highlights some of the reasons why CL isn’t as popular as other languages [2].

[1] https://youtube.com/watch?v=_ahvzDzKdB0

[2] https://www.dreamsongs.com/WIB.html

If you’re interested in Common Lisp, Practical Common Lisp is a good overview of the language [1]. Since you’ve done game programming, here’s a simple snake game I wrote a while back; you might find it useful to peruse the code [2]. You can find a couple of bigger libraries I wrote on my github if you’re interested in seeing more substantial code.

[1] http://www.gigamonkeys.com/book/

[2] https://github.com/SahilKang/cl-snake

I just finished reading the OSTEP book[1] and it has a nice chapter on SSDs[2]. The entire last portion of the book is about filesystems/disks so you might find it interesting.

[1] http://pages.cs.wisc.edu/~remzi/OSTEP/

[2] http://pages.cs.wisc.edu/~remzi/OSTEP/file-ssd.pdf

Can you share sources/data showing some of the fallout from covid-19 mitigation efforts?

Here’s one in Common Lisp if you’re interested in comparing loc with a lisp :) https://github.com/SahilKang/cl-snake

I would recommend contributing code to a well known FOSS project, or at least an existing project that you use or respect. I think hacking on meaningful projects will be clear milestones for yourself, which seems to be what you’re looking for.

To encourage you, here are a couple of contributions I have to Linux and Hadoop:

https://github.com/torvalds/linux/commit/0bef71093d446165964... https://github.com/apache/hadoop/pull/114

If you read through the commit messages and look at the patches, I think you’ll find that reaching these clear milestones doesn’t take an unattainable amount of skill; just a bit of patience and curiosity.

I haven’t used this myself, but Reason seems to fit your description of ‘learning any language’ while having static typing: https://reasonml.github.io

I’m more of a lisper, but OCaml should be a fun learning experience, especially if you enjoy expressive, static type-systems: https://ocaml.org

That’s an interesting opinion I’ve never heard before: suicide as an inalienable right. For clarity, you’re not referring to euthanasia by any chance, are you? If not, can you elaborate on why suicide is or should be an inalienable right?

From my understanding, people with mental health issues may be more likely to consider suicide. So my opinion is that suicide should be considered a symptom of an illness that needs medical attention as opposed to an inalienable right like free speech.

It sounds like we might work together; the only difference is that I do most of my dev work on my MBP so I consider it an expensive Linux machine instead of a chromebook :)

Yes, please do: what did being “the radio guy” entail?

Was it more software or hardware? I write software for a living so that’s what I’m more interested in; don’t know about parent comment, though.

GP seems like it’s venting or speculating rather than trying to make a point; the post starts off with “I’m going to provide no justification.”

You know, I’ve found myself doing the same thing: I usually have a git versioned ‘notes.org’ file in whatever repo I’m working in, and I’ll rebase it away before opening the branch for peer review. I also don’t feel the need to do this with my personal projects, not even the larger ones.

I suppose that’s because I insist on understanding more of the tech stack for my personal projects than I do for my work projects.

Your original comment doesn’t make that very clear at all; you might want to clarify who “they” are in your comment.

Have you considered an accelerator: https://www.ycombinator.com

I don’t know of any collected data to support the claims in this Quora answer, but I think it does a decent job highlighting the different interpretations of “popularity”: https://www.quora.com/Which-is-the-most-popular-Lisp-dialect...

What’s your definition of popularity when you say that Clojure “is by far and away the most popular lisp”?

I think this might give a more in-depth introduction to CL’s conditions/restarts: http://www.gigamonkeys.com/book/beyond-exception-handling-co...

Can you elaborate on the Californian bias with regard to community colleges? Is the California community college system better/worse than other states?

I’m a native Californian that went straight to a 4 year, but I sometimes think about how much cheaper college would have been if I had gone to community first.

I’ve been programming lisp for a few years now (Scheme then CL) and write Clojure daily for my current job. I initially described Clojure as: the worst dialect of lisp I’ve used, but the only one I’ve been paid to write in. It’s grown a lot on me over the past few months, but I still end up missing CL every now and then at work (I think I mainly like CL’s Slime more than Clojure’s Cider).

What were some unsettling points about the Clojure project you worked on? One thing I’ve noticed is that since Clojure is a relatively new language, a lot of newer lispers will start off with it, and I imagine that companies are more likely to try Clojure than CL as a first lisp. Consequently, the Clojure code you run into on the job may be of lower quality.