John BS @johnabs@qoto.org

@andrew Hey! I'm in a similar boat here, congrats! I hope both of our hard work pays off 😁

@akater @freemo @lupyuen I was being hyperbolic for effect lol 😂

@akater @freemo @lupyuen Well, it's ugly because of the ((((((((( ))))))))) that inevitably crops up.

Of course, there are autoformatters that help with this, (and things like rainbow parens...unless you're coloblind 😅 ).

Also, there's of course the issue of the sexp being read inside out, rather than left to right (hence my love of pipes in languages like julia, but that are sorely lacking in lisps).

So yeah, they're ugly and unergonomic in the most basic ways (IMO), but in the much more complicated ways they become nearly frictionless.

@freemo @lupyuen That's fair enough, I definitely understand the aesthetic aspect of doing knowledge work and problem solving.

.....But can I ask if you tried any of more recent developments in working with S-exp languages? I wouldn't want you missing out if there's anything I can do to convince you to give it another shot 😉 (ignore me if you've made up your mind lol)

There are quite a few Emacs packages for Lisps, such as:

[symex](https://github.com/countvajhula/symex.el)/[paredit](https://www.emacswiki.org/emacs/ParEdit)/[lispy](https://github.com/abo-abo/lispy) for navigating and editing any sexp language

you can get better diffs with something like [this](https://www.n16f.net/blog/improving-git-diffs-for-lisp/) or even better with something like [this](https://shivjm.blog/better-magit-diffs/) (though it's less integrated with Magit) should be the same here, nearly universal for sexp languages

Macrostep (at least in CL) is a great feature, as you can expand macros in-place to view what they would evaluate to before runtime (and can expand them all the way down to assembly, which is pretty dope).

There's also the amazing sticker's debugging feature from SLY, which is just incredible (it let's you "mark" an sexp to grab the output of some code for testing **without** changing the source by injecting some macro around it on the back end. Easily one of my favorite debugging features).

And of course, you can't forget about the awesome "back-in-time" debugging, that prevents you from needing to unwind the stack every time your program dies, you can debug in place and re-run the last few frames without restarting the whole thing.

Anyway, I just think Lisps are awesome, particularly common lisp, despite all of their warts. They're fast, have amazing debugging, and such well defined structure for editing/analyzing/automating so much of the programming process, that I really fell in love with it. I sort of understand the rustacean mindset now, but for lisp, if that makes sense 😂

@freemo @lupyuen Well right, but I see the parens as a feature, not a bug, even though they're ugly:

"Low/simple syntax" is good for people to pick up the language and makes macro writing much simpler.

Navigating by AST branches makes rapidly locating certain pieces of your code by muscle memory/touch typing much faster.

They eliminate the need for closing tags (e.g. \end{environment}, <\head>), or the (IMO) awful syntactically meaningful whitespacing of python among other languages, so you can format it however you want.

They allow for autobalancing of parens, and automatically confer the use of "tree-sitter" esque parsers without needing to understand the compilation process to produce a concrete syntax tree (which can change when languages evolve).

As an extension of the previous point, they allow for semantically meaningful diffs as compared to character/line based diffs which dramatically improves the readability of code modifications as compared to the current standard.

For this particular case, it's a fully featured language using Guile scheme, not just a markup language, so you can extend it as much as you want, call other software, do computational experiments on a cluster and pull the data back, create and directly insert plots, and who knows what else, all from within this one tool.

Etc.

To conclude, I think lisp is aesthetically ugly, but one of the most (if not the most) practical language when it comes to building tooling to make development easier, automate tasks with macros, and to facilitate code sharing (at least with people who understand s-exp syntax), and since there are so many flavors, you can always pick your favorite 😁

Thank your for coming to my TED Talk 😂

@freemo @lupyuen I personally like the lisp syntax because it enables structural editing and navigation, and the lack of \command{args} syntax which just becomes (command args). But I understand it's an acquired taste 😂

Also, this one doesn't *need* lisp syntax, it can also use emacs outline syntax which is close to org mode.

@freemo @lupyuen Oh, and what about org-mode?

@freemo @lupyuen Have you guys seen this one? https://www.nongnu.org/skribilo/

@tiago Ah, I see your point now, thanks for the clarification! 😁

@drmichaellevin @kws Rotovaping will allow you to remove the methanol over relatively low heat, (I think 30-40 C is sufficient under a vacuum to remove the methanol IIRC, but you may need to check a methods paper for it).

Economics+dynamic programming is really hard 😭

@drmichaellevin

Have you tried sonicating the solute in the water to dissolve it, and testing the concentration? You may be able to detect it if you can prepare some standards and have access to an HPLC/GC/ or mass spec. Do you know what wavelength the thing absorbs at so you can make a calibration curve for an optical detector? Do you know the expected solubility of the compound in your salt solution?

Alternatively if your compound is stable enough, can you rotovap it? If so, that may help at least remove the methanol, but your solute may still precipitate out of the water, particularly due to the salt. In this case you can readily determine the concentration by knowing the molarity of your original solution, and the volumes of your mixture and the rotovap product; should take out nearly all the guesswork assuming it stays soluble.

@CrypticMirror @neotoy

To quote Wikipedia, it's apparently supposed to refer to "Eurpoeans perceived to be particularly stylish and affluent socialites. It is often used ironically or self-referentially, and is not meant to be the European equivalent of the typical American derogatory term 'white trash'."

So, to answer your question, it apparently is not targeting a race or ethnicity per se, but the upper class of European expats living in the US.

Hence, I would argue it is not a racist term, but more of a classist one referring specifically to European "elites", which I assume likely has arisen from both Euroscepticism and (likely) from perceived cultural/behavioral differences between Europe and America.

My 2 cents, take them for what you will, lol.

@tiago I don't exactly see the issue here. Pardon my ignorance, but the following questions come to mind:

Do other foreign officials regularly attend presidential inaugurations?

Does the president regularly attend the coronations of other countries' dignitaries?

If the answer to either of these is no, then I don't see an issue at all.

I understand if other countries, particularly those of close proximity have leaders meet, but I doubt that leaders/royalty of every country in the world are attending, and frankly it would be strange if they did IMO. It's good to have pleasant relations with other leaders, but surely those can be established outside of the pomp of these overblown ceremonies, right?

@leahdriel And all these telomeres sure do a number on the living! 😂

@doclomieu @freemo Aww shucks, thanks fellas 😁

For anyone interested, I owe a lot of the final look to sanding with 0000 steel wool after the initial shaping, being very careful to remove all the dust before applying the finish (cyanoacrylate for grip and protection, at least 12 coats), and then polishing up to 12,000 grit with water. It takes a while but I think it pays off.

I wish I could have gotten the chatoyance of the grain in the pictures, because it's honestly prettier in person when the light hits it just right!

I made this out of Kingwood and got a really nice grain match across the cap and the body!

@freemo I know you like fountain pens (or at least calligraphy), what do you think?

#fountainpens #woodworking

While R isn't my favorite language of the ones I regularly use, I know you #rstats people adore it, so here's a fun package you should try out:

https://github.com/dirkschumacher/transduceR

If you like functional style, but want efficiency too, try out transducers, they're an amazing little tool that I'm still picking up, but they give you pipelines that don't create intermediate arrays (and composable reductions, lazy evaluation in this case, etc). Thus, they still provide clean, familiar functional syntax but with a pretty sizable performance boost!

Here's a conceptual primer on them from Clojure as well:

https://clojure.org/reference/transducers

I hope this proves useful to some of you! 😁

@andrew No problem! Not sure if it was useful at all, but I tried 😂

@tiago My favorite latex "replacements" are org-mode/RMarkdown/Weave.jl

You can still use latex where needed, and it compiles through latex at the end, but you get a lot more (including code execution, selective export, inline figures, easier tables, etc) for a lot less of the annoying syntax, while maintaining the beautiful typesetting. If you haven't tried them, I heavily suggest giving them a shot!

If anyone is interested, I can post an example document as well 😄