Simon 𐕣he 🪨 Johnson

Static typing itself is a trade off as well. It introduces mental overhead because you are restricted to a set of statements that can be expressed using a particular type system, and this can lead to code that’s written for the benefit of the type checker rather than a human reading it. Everything is a trade off in practice.

You mean code that’s written to the benefit of a low efficiency enterprise workflow, which is my love hate relationship with Typescript. Best out choice out of a pile of shit.

Why not just run a hypervisor and use containers?

That’s been the opposite of my experience using Clojure professionally. You’re actually far more likely to refactor and clean things up when you have a fast feedback loop. Once you’ve figured out a solution, it’s very easy to break things up, and refactor, then just run the code again and make sure it still works. The more barriers you have there the more likely you are to just leave the code as is once you get it working.

This is more of a how the saussage is made issue in my experience than a tooling selection issue. Clojure may make it easier to do the right thing but the actual forcing function is the company culture. Self-selection of Clojure as the company’s tooling may create a correlation.

Most companies have the ability to implement fail fast workflows for their developers they simply choose not to because it’s “hard”. My preferred one is Behavior Driven Development because it forces you to constrain problems into smaller domains/behaviors.

When you’re dealing with types or classes they exist within the context they’re defined in. Whenever you go from one context to another, you have to effectively copy the data to a new container to use it. With Clojure, you have a single set of common data structures that are used throughout the language. Any data you get from a library or a component in an application can be used directly without any additional ceremony.

An Adapter is typically a piece of code that transforms data between formats at various boundaries. Typeclasses remove the need for Adapters for functionality at library boundaries e.g. most thing have map where in javascript I can’t do {}.map with the EMCA standard. However typeclasses do not solve the problem of the literal data format and functionality differences between different implementations.

For example I call some API using a Client and it returns bad gross data based on how that API is written, I would use an Adapter to transform that data into clean organized data my system works with. This is extremely helpful when your system and the external system have references to each other, but your data taxonomy differs.

A real example is that Google Maps used to have a distance matrix API where it would literally calculate matrices for you based on the locations you submit. Circa 2018 Google changed it’s billing driving up the prices, which lead a lot of people to use alternative services like Here.com. Here.com does not have a distance matrix API. So in order to build a distance matrix I needed to write an adapter that made N calls instead of Google’s 1 call and then stuff the Here.com responses into a matrix response compatible with Google’s API which we unfortunately were using directly without an internal representation.

These concepts are still used/useful within functional contexts because they are not technical concepts they are semantic concepts. In functional languages an Adapter may just be a function that your responses are mapped over, in OOP style it might be a class that calls specific network client and mangles the data in some other way. Regardless of the technical code format, it still is the same concept and procedural form, thus it’s still a useful convention.

Outside Lisps, I have not seen any environment where you can start up your app, connect the editor to it, and then develop new code in the context of a running application.

This is absolutely true, however I don’t particularly value this feature because most engineers typically already cannot separate concerns very well in industry so IMO if I had this I would not want people to use it. Very much a “it works ship it” trap.

. I also find that language design very much impacts conventions and architecture. Clojure’s focus on immutability naturally leads to code that’s largely referentially transparent and where you can reason about parts of the application in isolation without having to consider side effects and global state.

I’m with you here. I basically force almost every code base I end up working on into functional forms as much as possible.

When you pass data around, you can always simply look at the input/output data and know what the function is doing. Transforming data also becomes trivial since you just use the same functions regardless of what data structure you’re operating on, this avoids many patterns like wrappers and adapters that you see in OO style

Yep agreed, almost every role I step into I push the org to enforce this style of work.

Transforming data also becomes trivial since you just use the same functions regardless of what data structure you’re operating on, this avoids many patterns like wrappers and adapters that you see in OO style.

This is where you lose me, you still have wrappers and adapters, they’re just not classes. They’re functions. I still use those words regardless if I’m in Haskell or Typescript. Semantic meaning shouldn’t be lost in functional style because it’s part of architecture. Functional programming simply gives your basic building blocks better names and better division of responsibility, e.g. functor, applicative, monad, etc.

I found Clojure jobs were generally pretty interesting. One of my jobs was working at a hospital, and we were building software for patient care. So we got to go to the clinics within the hospital observe the workflow, builds tools for the users, and then see how it improved patient care day to day. It was an incredibly rewarding experience.

Sounds like you got double lucky. Hasn’t really been my experience in the medical space. I find larger institutions like that very unreceptive to how software is made and often the environments are constricting and lead to bad outcomes that “nobody can really figure out why”. It often starts at timesheets and gets worse from there.

For me, the language matters a lot, and Clojure is the only language that I’ve used for many years that I’m still excited to write code in. Once you’ve worked with a workflow that’s fully interactive, it’s really hard to go back. I really enjoy having instant feedback on what the code is doing and being able to interrogate the app any time I’m not sure what’s happening. This leads to an iterative development process where you always have confidence that the code is doing exactly what you expect because you’re always exercising it, and experimentation become much easier. You can just try something see the result, and then adjust as you go.

Yeah you can definitely have this kind of stuff in other languages. It’s gonna be similar workflows that are generally BDD & REPL based but you have to have someone who knows what they’re doing do architecture, tooling selection, setting conventions, and helping to put it all together into a maintainable system. Very often that’s skipped at most companies, and I’ve found it to be a lucrative skill in my career.

Right, but what I’m saying the design to need these things was likely based on Deepin running their own distro. They don’t have to consider the security guidelines of other distros like KDE or Gnome, XFCE or Enlightenment would.

Yeah I just haven’t really held out for one. At one point I have this fear that on average regardless of language I’m gonna see the same shit everywhere, so I typically pick by project interest and scale. If I wasn’t such a little cockroach about having a stable income I could have had some fun opportunities holding out for some Haskel, Erlang or Clojure jobs, but I didn’t.

I was once interviewed by a startup that was a crypto payments processor targeting the central American market and the interviewer let it slip that I shouldn’t worry about runway because it comes from a fairly large crypto fund that the founder owns that’s payed into by USAID/NED style soft intelligence services.

I immediately got the ick and I was like this is not something I want to involve myself in for stability’s sake but god damn I could have had a peek behind the curtain.

This is what vertical integration between distros and GUIs often leads to. This could be completely innocuous from Deepin’s end, because that’s just how they made it work in Deepin because they have vertical integration on their own stack. However, It’s completely bad form.

In general Deepin seems to adopt a lot of commercial software industry practices in building its tools, which I’m sympathetic to on some level, but it’s very obvious that the Linux community is not going to accept default-on telemetry. They should have known better after the CNZZ incident.

I’ve found it hard to find jobs with Clojure/Haskell/Rust. I typically look for interesting projects and industries that don’t make me feel icky even though they end up doing so because everything is fucking enterprise sales. My career has kinda been Bar Rescue for idiot companies who have blundered into an extremely hard problem and need someone to actually figure it out before the software stack implodes on itself.

I love Lisp, that’s why I like doing industry work in JS, because it’s very lisp like.

However if you gave an average industry programmer Lisp today they’d fuck up so much worse than the garbage enterprise grade language code that exists today. I switch jobs probably every 4 years and on average I teach 3 people a year what a closure is.

Lisp has a lot of great solutions for a lot of real problems, but these people quite literally fix one bug and create 3. I had a 10+ YOE Tech Lead tell me the other day that they kinda just ignore the error output of the TS compiler and it made me want to tear my eyes out.

don’t even try to learn what a software dependency

Everyone at my company keeps using the term “dependency hell” when referring to literally dependency management and order of operations with a modern package manager like NPM that tracks versions and dependencies.

They’ve literally never experienced working with dynamically linked libraries and they think it’s so hard because they have to understand a tree that exists in data form (e.g. package-lock.json) and can be easily visualized vs a tangled file system and LD_LIBRARY_PATH or Windows standard search order / HKEY_LOCAL_MACHINE\SYSTEM\CurrentControlSet\Control\Session Manager\KnownDLLs.

It’s pathetic.

Margaret Hamilton’s first job out of undergrad was working for Lorenz. She was incredibly accomplished with several stints in top labs, by the time of Apollo. It’s not like opportunities for trail blazing software fell out of the sky on shlubs who barely passed undergrad data structures and algorithms courses.

Vaxry is not a very smart guy. He originally got a wrist slap by FDO saying don’t do your toxic shit here. Then he followed it up by going postal on the FDO mailing list. Then he put up a blog post where he was like like “SJWs are coming for me”.

https://blog.vaxry.net/articles/2023-inclusiveActivists

The entire argument is that you can’t make an exclusionary space for people (no definition of what that means) but you should be able to call them slurs. Who would want anything to do with him? He should have gone full tilt and made a list of slurs you should be allowed to say beyond just arguing for the R-slur. That would have really convinced people he’s not an extremely toxic right wing weirdo.

https://blog.vaxry.net/articles/2023-hyprlandsCommunity

This was his non-apology where he says “lets be real” a lot which is a common way of just ignoring a criticism and then he follows it up with, I should have banned that user instead of doing what I did.

Asking for professionalism in the OSS community is not a huge deal. It’s also quite literally not even about the code AFAIR Drew Devault is still taking Vaxry’s patches. He just doesn’t want him in the community starting shit with people.

• Janitor
• Babysitter
• Contortionist

come around on social programs.

Wat.

Anarchists are the ones who are consistently making social programs from scratch. Direct action is and has always been about feeding people as well as sabotaging bulldozers.

https://foodnotbombs.net/new_site/