John BS @johnabs@qoto.org

So, really cool new tool I've learning as I'm working with lisp for my startup: [symex.el](https://github.com/countvajhula/symex.el) for structural navigation and editing is VERY efficient, somewhat vim-based, and I really like it a lot. As an added bonus, some of its dependencies (e.g. lispy) are very useful for multi-lining s-exps (aka symexs) and formatting them, and it plays nicely with sly, which is even better!

Additionally, for all you #rstats people out there (who are asking why I included the tag on a post about Lisp), maybe take a quick look at [this](https://lisp-stat.dev/about/). I'm currently using it myself, and I've found it's pretty good for most basic things, and you may like it if you give it a try (or maybe not, it's not yet as full featured as R and its various packages yet, but it does benefit from some things I don't think you can get easily from R). Also, here's a super quick demo [thingy(?)](https://lisp-stat.dev/docs/examples/plotting/).

I know other tools leveraging tree-sitter try to achieve similar functionality, but when the code is already in an AST format, it really eliminates the guesswork and makes the experience seamless!

@trinsec Awesome, I'm looking forward to it!

And no, they are literally the dumbest creatures on earth, and they're blind: they just sit in their holes and wait for movement and often attack leaves or grass 😂.

They just get cranky when people open the box because imagine if you were blind and a giant ripped the roof of your house off and started chucking cheeseburgers at you. I'm sure you'd be angry too, even if you appreciated the food 😂😂😂

@trinsec a) Very cool, I'm hoping you post update pictures if they take root!

b) Also, just because you need to know this, you could probably keep a tarantula in there if you wanted (which is true of literally any container...but still, technically a potentially useful fact 😂)

@olives Its about PoW cryptocurrencies and how pooled mining inherently causes malicious attacks due to the structure of the algorithm/incentives of the reward contracts, and we have a lot of proofs and simulation results to back us up, but I'm still nervous, lol.

I'm giving my very first academic conference talk tomorrow, and I'm pretty nervous, even though I'm pretty confident in my slides, and my talk.

Regardless, anybody out there who sees this, I'd appreciate it if you could wish me luck.

@usernameswift @getimiskon

Y'all think this is a half-assed attempt to prevent more sophisticated SQL injection?

No idea, honestly, but my guess is that someone wasn't 100% sure how to sanitize their inputs and decided to limit input length and special character sets to cover themselves, just in case.

I personally think I should be able to use full unicode for my passwords, who's with me? 😂

@tiago It's certainly not like most Americans are in favor of the various wars our country has engaged in for ~93% of our its existence. I suspect the musical is a way to bring the bad behavior to light in a way that is more approachable for most audiences than watching straight up gore and snuff.

Similar to the Shen Yun performances made by the Falung Gong victims of the CCP, I suspect this is a group of people unhappy with the status quo and trying to spread the word.

Of course, since the playwrights can be viewed as "on the side of" America it can certainly come across as satirical or dismissive of the awful things that have perpetrated, but due to the highly polarized political climate, and the fact that most artistic people are very left leaning, I suspect it is moreso the case I originally described.

@zleap @ScienceMagazine Oh, my bad, I must have missed the intention of your original comment 😅

@zleap @ScienceMagazine And if so, so what? What an accusation to level at someone.

Excellent writing and rigor are not conflicting forces, and I'm frankly sick of people (not you in particular) trying to convince me that the status quo of most academic communication is acceptable. It is abysmal, and you need only a cursory web search to see how many researchers acknowledge the rotten "style" of modern academese, while vastly too few actually are willing to take a risk to write well in the face of the deluge of drivel they have to wade through.

Most researchers actually appreciate well written, compelling and evocative research articles (see Helen Sword's Academic Style guide for reference). And frankly, I would argue it should be a requirement for publication. The fact that we use convoluted language as the proverbial lispstick for the poorly-executed-research pig is indicative of what we value as researchers: more than truth or doing good, solid, hypothesis-driven research, we value the veneer of erudition as a shibboleth that obscures the meaning of the work to everyone but those who are in our tiny, siloed off, fiefdoms.

The fact that some researchers want their work to be readable by the masses rather being filtered through the "Science Communicators" who often bastardize the message is an amazing thing. Anti-intellectual sentiment is rising in many areas, and a disdain for "basic" research is following it. What better way to correct for this than to write and publish your papers in an accessible way such that the people actually funding your research can know what is being done with those tax dollars? It doesn't take much extra effort, and the payoff is amazing for everyone.

Open Access is not just about the paywall, it's about making our work accessible on as many levels as possible. If that means writing a companion article, annotating your equations, or deviating from the 3rd person passive laden academese, then do it. Everyone will be better off for it, our societies will thank us, and we can do it while maintaining rigor.

I maintained my streak of all As, and my final project may end up being published if I can convince a collaborator to chat about it, and I'm finally going on a trip with my wife (though, it's to a conference lol).

Overall, it was a pretty good semester, and all it cost me was my sanity 😂

@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/