☆ Yσɠƚԋσʂ ☆ @ yogthos @lemmy.ml

Posts

9,917

Comments

10,655

Joined

6 yr. ago

Moderating

---

Clojure jobs are definitely around, I got involved in the community early and wrote a few libraries that ended up getting some use. I also joined local Clojure meetup, and ended up making some connections with companies using it. I've also worked in a team lead position in a few places where I got to pick the tech stack and introduced Clojure. I didn't find it was that hard to hire for it at all. While most people didn't know Clojure up front, most people who applied were curious about programming in general and wanted to try new things.

It was basically way ahead of its time.

I think it's more of the latter. There are a lot of languages and each one has its own quirks, libraries, and patterns. Even as an experienced dev, you might know what you want to do conceptually, but you might not be sure what the best way to do that in a particular language is. LLMs can be used in a similar way to StackOverflow to look up these sort of things.

I guess I've been lucky, I've been working with Clojure professionally for over a decade now, and every team I've worked on was very competent. Could be that there's a selection bias at play with teams that use a language like Clojure though since it tends to appeal to experienced developers.

It's like an artifact from an ancient and more advanced civilization. :)

It's really impressive to think what was achieved with such limited hardware compared to today's standards. While languages like Clojure are rediscovering these concepts, it feels like we took a significant detour along the way.

I suspect this has historical roots. In the 1980s, Lisp was primarily used in universities and a small number of companies due to the then-high hardware demands for features like garbage collection, which we now consider commonplace. Meanwhile, people who could afford personal computers were constrained by very basic hardware, making languages such as C or Fortran a practical choice. Consequently, the vast majority of developers lacked exposure to alternative paradigms. As these devs entered industry and academia, they naturally taught programming based on their own experiences. Hence why the syntax and semantics of most mainstream languages can be traced back to C.

Common Lisp and Smalltalk provided live development environment where you could run any code as you write it in the context of your application. Even the whole Lisp OS was modifiable at runtime, you could just open code for any running application or even the OS itself, make changes on the fly, and see them reflected. A fun run through Symbolics Lisp Machine here https://www.youtube.com/watch?v=o4-YnLpLgtk

Here are some highlights.

The system was fully introspective and self-documenting. The entire OS and development environment was written in Lisp, allowing deep runtime inspection and modification. Every function, variable, or object could be inspected, traced, or redefined at runtime without restarting. Modern IDEs provide some introspection (e.g., via debuggers or REPLs), but not at the same pervasive level.

You had dynamic code editing & debugging. Functions could be redefined while running, even in the middle of execution (e.g., fixing a bug in a running server). You had the ability to attach "before," "after," or "around" hooks to any function dynamically.

The condition system in CL provided advanced error handling with restarts allowed interactive recovery from errors (far beyond modern exception handling).

Dynamic Window System UI elements were live Lisp objects that could be inspected and modified interactively. Objects could be inspected and edited in structured ways (e.g., modifying a list or hash table directly in the inspector). Modern IDEs lack this level of direct interactivity with live objects.

You had persistent image-based development where the entire system state (including running programs, open files, and debug sessions) could be saved to an image and resumed later. This is similar to Smalltalk images, but unlike modern IDEs where state is usually lost on restart.

You had knowledge-level documentation with Document Examiner (DOCX) which was hypertext-like documentation system where every function, variable, or concept was richly cross-linked. The system could also generate documentation from source code and comments dynamically. Modern tools such as Doxygen are less integrated and interactive.

CL had ephemeral GC that provided real-time garbage collection with minimal pauses. Weak references and finalizers are more sophisticated than most modern GC implementations. Modern languages (e.g., Java, Go, C#) have good GC but lack the fine-grained control of Lisp Machines.

Transparent Remote Procedure Calls (RPC) allowed Objects to seamlessly interact across machines as if they were local. Meanwhile NFS-like but Lisp-native file system allowed files to be accessed and edited remotely with versioning.

Finally, compilers like Zeta-C) could compile Lisp to efficient machine code with deep optimizations.

Again, the meme says absolutely nothing about beginners. It's the coding practices of experienced developers today. And if those look indistinguishable from beginner practices to you, then perhaps you see the problem.

For sure, it's a lot easier to do a lot of stuff today than before, but the way we build software has become incredibly wasteful as well. Also worth noting that some of the workflows that were available in languages like CL or Smalltalk back in the 80s are superior to what most languages offer today. It hasn't been strictly progress in every regard.

I'd say the issue isn't that programmers are worse today, but that the trends in the industry select for things that work just well enough, and that's how we end up with stuff like Electron.

What does this have to do with being a beginner programmer and punching down? The meme is about how we do programming in general today vs the way it was done before.

I'm gonna treat this as a rumor until we have an official statement from China that it's actually happening.

I very much hope this will end with a few border skirmishes. It's clearly not rational to let this escalate, but unfortunately these things can easily take on logic of their own. Each retaliation can lead to a bigger retaliation from the other side, and things can easily spin out of control. Let's hope cooler minds prevail in the end.

that's right these are two completely unrelated events, you shouldn't think too hard about these amazing coincidences

Pakistan is a critical part of BRI, and India is an important member of BRICS. A war between Pakistan and India will impede trade over BRI and sour relations between two biggest BRICS members. Given that the US is in economic war with China, it seems pretty obvious who the biggest beneficiary of all this is.

I'm guessing they did at least a minimal assessment of that. :)

Oh yeah, that could be pretty amazing. It would really be strictly superior to actually owning a scooter since you wouldn't have to worry about having a parking space and stuff. This is also a great illustration of the direct benefits of collective ownership.

That's a rather reductive way to look at it. You can't just snap you fingers and go from capitalism to communism. In fact, a big part of the argument Marx makes is that communism will not be possible until productive forces are sufficiently developed. All these countries have communists in power, but they are in a socialist stage of development. Furthermore, the dominant global system is itself capitalist, which puts limits on what individual countries can accomplish internally.

Saying that they merely change the way capitalism is managed ignores a fundamental difference between the two. The goal of private enterprise is to create profit for the owners through appropriation of the value the labor of the workers creates. On the other hand, the primary goal of the state owned enterprise is to provide social value. In this scenario, the labor of the workers directly benefit society and workers themselves. So, while the social relations within the state owned enterprise may resemble those in private capitalist enterprise, their goals are very different.

From what I've seen the driving culture in China does seem to be a lot more relaxed than in western countries. I've seen lots of videos of people driving scooters on sidewalks and so on. The legal responsibility is a good question, I would assume the company making the scooter would be responsible since they're making the self driving system for it.

If this tech works well I can see it making things incredibly convenient. You could just leave your scooter somewhere, and then have it come find you, or you could even share a scooter with a friend this way.

these are the minds of people running the US government

21T in 17 years does seem fantastical to me as well.