Are we the programming equivalent of "fake" martial arts?

[didibus]

@Richard_Heller

The original UFCs didn’t ban many moves and they didn’t want to ban any. I don’t believe the Gracies banned anything when they were doing their challenge matches prior to the UFC. The only reason anything is banned is so that they can get sanctioned by the states

This seems true. The sport in Brazil was called Vale Tudo, and apparently had no rules. Nowadays it says it has banned groin strikes, eye gouging, fish hooking and fighters have fingerless gloves, but everything else is till allowed, like head butts and soccer kicks, as opposed to UFC which has more restrictions.

@Richard_Heller

Hasn’t that kind of been proven, though? There’s nothing you can do in one language that is impossible to do in another

Proven which way?

@Richard_Heller

So, better or worse really just comes down to how easy it is to achieve the goal you’re trying to accomplish. Writing a device driver in Clojure would be very difficult, for example

The problem is with the word “easy” and trying to formalize it. I think people try to isolate the developer and the machine from the language, and then want to see if there’s anything left inherent that makes one language better than others.

Personally I think it’s a mistake to try and isolate the language from developer and machine. A programming language is intrisectly about the relationship between developers and machine.

Which tends to be how I pick my programming language. First, choose a language that can deliver the expected end result. This is based on the runtime characteristics and compatibility of the language when running on my target machine. Clojure for example doesn’t run on iOS, so it’s a no go for that. Most of the time, my target machine and my expected end result still allows for a large selection of possible programming languages, Clojure often being a valid option.

At that point, I thus turn my focus on the developers. What language do they want to use? Which language do they enjoy the most?

When it comes to me, I enjoy Clojure the most. This means I want to use it.

I’m someone who believes strongly in developers needing to enjoy themselves on their project. I think that’s critical to success on any given project. Every developer has different motivation, and thus will gain enjoyment from different aspects. Some devs don’t care about the language at all, they care more about the paycheck, or building cool stuff, or they care about not needing to have to learn anything new, etc. Some, on the other hand, care about continuously learning new things, and about being allowed to use a language that fits their prefered style.

Honestly, that part is a tougher call, but basically, after having restricted the language choices from the machine side of things, developers are what drive the selection.

In my experience, when people like Clojure, they really really enjoy it. That’s why it has a striving small community. I’ve found that well mentored, most people come to enjoy Clojure, but maybe not always enough to really make it their main language. What I’ve yet to know for sure, is in general, it seems people more interested in languages tend to like it, but people more interested in building stuff, even if they enjoyed Clojure, they gravitate towards popular language which have more demonstrations of building cool stuff.

[Richard_Heller]

@didibus

This seems true.

It is. I was heavy into martial arts at the time of the first UFC. The school I trained at had a few people who trained under the Gracies, so we had insight into what was going on before the event happened. It was held in Denver because they couldn’t do it anywhere else. They wanted to hold it in Los Angeles, New York, or Las Vegas but those athletic commissions wouldn’t allow it.

Fun side note. Royce was the worst fighter in the family. He was picked to enter the tournament because he was the smallest and the Gracies’ main goal for the UFC was to show off their art so they could make more money from seminars and training. They didn’t think that would work if they put a 220 lb guy in, but having the 180 lb guy win would.

@didibus

Proven which way?

Mathematically. For example, you could write device drivers in Clojure by having a Clojure program that generates the machine code. Device drivers don’t run in C, but writing them in C is a shorter path to generating the necessary machine code. Similar with your iOS example. Swift doesn’t run on iOS, either. The machine code does. You could write a Clojure program that generates iOS machine code that allows Clojure as we know it, with the REPL and whatnot, to run on iOS. For most projects, that’s too much effort, though.

@didibus

Personally I think it’s a mistake to try and isolate the language from developer and machine.

I agree with that, 100%. The martial arts have a similar problem of people wanting to choose the best one or prove that one is inherently better than another instead of focusing on the goal, which is to be able to defend yourself and your family if something bad happens. I believe being a polyglot helps you become a better programmer and also believe that the best martial artists train in multiple styles. There are some exceptions, but I believe that’s the case in general. That’s why I think the OP’s question is valid. Is Clojure selling snake oil? That has crept into the martial arts and it’s valid to question whether it’s also creeping into programming.

[didibus]

@Richard_Heller

It is. I was heavy into martial arts at the time of the first UFC

TIL that half the Clojurians are big into MMA

@Richard_Heller

Mathematically

Okay I wasn’t sure you meant proven that Clojure was worse than other languages, or something else. But I see now.

@Richard_Heller

You could write a Clojure program that generates iOS machine code that allows Clojure as we know it

True, but I think we’re stretching things too far at that point. I think we want to discuss the existing set of Clojure compilers/interpreters. Or similarly to what I mean, trying to isolate the language from its implementations is also in my opinion a counter-productive thought exercise.

For example, it matters a lot if we’re using babashka, Clojure JVM, Clojure CLR, Clojerl, Ferret, ClojureScript, Arcadia, Joker, etc.

That said, this is a good argument for Clojure. The fact it already has so many implementations, which more or less share the same language syntax and semantics. As a user, this is a huge advantage. It shows that you can take your knowledge of Clojure to many places, and it also shows that the language seems relatively easy to write an implementation for.

@Richard_Heller

I believe being a polyglot helps you become a better programmer and also believe that the best martial artists train in multiple styles

Totally agree .

One thing I personally like about Clojure (and Lisps in general), is that they tend to be polyglot within themselves. One syntax that can adapt to all styles. The dynamicity and macros make it you can often use and learn multiple styles within the language.

In that sense I do feel Clojure is closer to MMA itself. See, as opposed to martial arts, when you write a program, you can’t always freely just incorporate techniques and styles from different programming language and paradigms. So if you want to have a polyglot approach to writing your program, it isn’t always easy. When you pick up Clojure though, you are more enabled to do so. You can start using functional programming, immutable functions, lazy and eager evaluation, generics and polymorphics, OO, CSP, multi-threaded, futures/promise, agents, STMs, data streams, map/reduce, list comprehensions, recursion, loops, optimistic and pessimistic locking, logic, and all other kind of things.

So Clojure gives you a lot of programming styles and constructs, and allows you to easily add whole new ones to the language itself, in a framework where they can often be mixed together and used together within the same program.

Even beyond the programming constructs, styles and paradigms, Clojure also allows you to often mix standard library. Right now, in Clojure, I can combine libraries from Java, Clojure, Python and C together with relative ease.

So in effect, one of my reasons for liking Clojure, is that it does allow me to train in multiple styles and even use them together when writing a program.

I think this is really the essence of my interest and preference for Clojure (and Lisps) over most other language. It is much harder to incorporate multiple styles in say Java than it is in Clojure. Look at how complex the machinery for Aspect programming is in Java. Even with Graal, which is awesome, and could bring a polyglot library eco-system, it won’t bring in a polyglot paradigm/style/constructs to Java.

Python and JavaScript can also somewhat mold themselves to multiple styles and constructs, but don’t have the polyglot hosted nature of Clojure. Also they don’t do it as effectively in my opinion. And I personally dislike their default style. Whereas for me, Clojure’s main style is my preferred: functional, immutable, data-oriented, interactive, while letting me explore and bring in many other style into it as I see fit.

Truth be told, I do have a small gripe with Clojure. It makes it really hard to use the imperative style. The lack of imperative loop constructs is something I wish it allowed more freely. You can bring your own macros to bring back a for-loop, a return, a mutable variable, etc. but those tend to not be as efficient since you kind of have to rely on exceptions under the hood. 99% of the time, I prefer other styles to the imperative style, but every once in a while, even if just for toying, I wish it had those more readily available. I also understand why it doesn’t, I think having had them, people would take a lot longer to learn the alternative styles.

[Richard_Heller]

@didibus

So if you want to have a polyglot approach to writing your program, it isn’t always easy. When you pick up Clojure though, you are more enabled to do so.

I haven’t gotten to where I’ve experienced that with Clojure. So far, Clojure seems to be single paradigm to me. Java shoehorns everything into OOP and Clojure shoehorns everything into FP.

The languages that are multi-paradigm by design, Python, JS, Common Lisp, tend to have kind of half-baked versions of the different paradigms. If you really like OOP, you’re better off with Java or C++. If you really like FP, you’re better off with Clojure or Haskell. I like using languages that allow different approaches but don’t really mind when they don’t. I don’t miss or try to write FP code in Java and don’t miss or try to write OOP code in Clojure.

[seancorfield]

@Richard_Heller

If you really like OOP, you’re better off with Java or C++. If you really like FP, you’re better off with Clojure or Haskell.

As someone who spent so much time working with the C++ language – as a compiler writer, as a C++ programmer, and especially as a member of the ANSI C++ Standards Committee for eight years – I have to challenge that: C++ is absolutely a multi-paradigm language and neither it nor Java are what OOP is supposed to be about. If you really like OOP, you’re better off with Smalltalk or Ruby!

It’s really unfortunate that Java has become almost synonymous with OOP in so many people’s minds

[Richard_Heller]

@seancorfield

C++ is absolutely a multi-paradigm language and neither it nor Java are what OOP is supposed to be about.

My point there was that if OOP fits you and that’s the style of coding you would rather do, you’d be better off with those languages than trying to fight the grain with an FP language like Haskell or Clojure. While C++ is multi-paradigm, to me it’s the one language that got OOP right. I know people bring up Smalltalk and how there’s supposed to be message passing and all data should be private, but if you look at all the tenets of OOP, C++ has them all in spades in a way that is useful for getting real work done.

@seancorfield

It’s really unfortunate that Java has become almost synonymous with OOP in so many people’s minds

I don’t think truer words have ever been spoken.

[didibus]

@Richard_Heller

I haven’t gotten to where I’ve experienced that with Clojure. So far, Clojure seems to be single paradigm to me

I’ll eskew the debate on what is a paradigm and all that. I’ll say for me, it was more about the set of things that together are maybe a combination of styles, paradigms, constructs, features, target platforms and libraries.

I feel Clojure has a very broad selection of all these. Not that other languages don’t offer a good selection either. I think especially in the last few years, most languages have realized they need to converge and provide a bigger selection to the table. I just find that Clojure and Lisps seem to bring in those selection of things in a way that feels better integrated and more natural to the language. That last bit is definitely subjective.

Anyways, so here’s some examples:

• First class functions and higher order functions
• Immutable persistant data-structures and pure functions
• Type polymorphism
• Single and multiple function dispatch
• Open polymorphism
• Abstract data types
• Custom types
• Heterogeneous data entities
• Record entities
• Pipeline programming
• Live programming
• Visual programming
• Rule based programming
• Metaprogramming
• Logic programming
• Object oriented programming
• Generic programming
• Declarative programming
• Dataflow programming
• Concurrent programming
• Functional programming
• Lazy evaluation
• Eager evaluation
• Infix/prefix/postfix notation
• Homoiconicity
• STM
• Transducers
• Sequences
• Map/reduce
• List comprehensions
• Recursion
• Concurrent sequential processes
• Coroutines
• Async/await
• Arbitrary precision arithmetics
• Async IO
• Backend programming
• Frontend programming
• Optional types
• Dynamic types
• Contracts
• Data schemas
• Entity component systems
• Multi-threading
• Parallel folds and fork/join
• Hot code reload/swap
• Dynamic bindings
• Lexical bindings
• Optimistic locking
• Pessimistic locking
• Agents
• Future/Promise
• Destructuring
• Pattern matching
• Regular expression
• Fluent interface
• Probabilistic programming
• Event driven programming
• Data driven programming
• Data oriented programming
• Thrown exceptions
• Returned exceptions
• Condition restart systems
• Monadic programming
• Point free programming
• Compiles to JS
• Compiles to JVM
• Compiles to CLR
• Compiles to native
• Runs interpreted
• Etc.

Those are all things I’ve personally trained and learned using Clojure. I’m probably forgetting a few.

Its not that some of those weren’t available in my prior languages (though some weren’t), but it’s also the access to them and the integration they have. There’s just something with Clojure where I feel first of all, the community really is interested in learning new techniques and brings them to my attention first. Then there is often a very simple library, simple enough for me to understand the source, which adds the technique to Clojure. Generally, the syntax is malleable enough that it works well no matter what the technique is. The macros allow for techniques which would normally require a compiler change to be brought in earlier to Clojure as just a library, so I don’t have to wait for the language designers. And the REPL lets me sparre with all these techniques head to head, where my learning cycle in other languages is much slower without that instant feedback and interactivity.

Now in a typical program, I don’t necessarily make use of all this, but you’d be surprised for programs of considerable size, there’s definitely going to be a few of those in use. And more so, for different programs I might leverage a different set of those. But in the end, most of it is about enabling me to learn and practice more techniques.

[lilactown]

TL;DR:

So, is Clojure a “fake programming language”? Honestly: kinda, a little bit …

What’s a fake martial art?

Discussions about fake martial arts (or fake programming languages) are always dominated by debate over efficacy of whatever practices fall under that umbrella. To me, this misses what makes a martial arts seem “fake.”

When I think about “fake martial arts” I don’t actually think of the general practice of e.g. aikido or wing chun. I instead think of a person who practices one of those martial arts, who is ignorant/naive enough to not see see the limitations of those practices and how they fit into the larger context of combat, and a community that encourages this ignorance.

To give an example, I recently received my black belt in Brazilian Jiu Jitsu - one of the “real” martial arts. There are more than a few people I’ve met through the years who have looked up to black belts in whatever martial arts as gods. Yet, experience has taught me the limits of specializing in grappling, and how even clueless grapplers can be dangerous if given the right inspiration.

In general, most people I know through combat sports are very aware of the way their skills and experience fits into the wider context of unarmed combat. There is something about BJJ, Muay Thai, Boxing, Wrestling, etc. that grounds the majority of practitioners in a better sense of their physical capabilities (and their lack thereof).

I think it’s a combination of practice (sparring) and a shared set of values that encourages a lot of interchange between the different sports. I’ve not only trained with great BJJ practitioners but also amazing wrestlers, world class judoka, professional MMA fighters, etc. This interchange of ideas and experience leads to a better understanding of where one personally fits in the world of martial arts and how their art prepares them for people different from them.

I see “fake” martial arts as an umbrella term to refer to a group of people who lack a basic practice of testing their assumptions about how combat works (sparring) and/or a community that discourages interchange of ideas with other communities. This leads the majority of people to misunderstand how they fit into the wider world of martial arts. Then they go and claim wacky stuff that - when in a discussion with serious martial artists - seems obviously uninformed, despite their years of practice.

So, is Clojure a “fake programming language”? Honestly: kinda, a little bit.

Clojure is a very pragmatic language, and I have used it professionally for about 2 years. I have shipped lots of Clojure code to production and brought much money to my employers and joy to my users. So I don’t think it’s a lack of practice on our part. I think that in general, we as a community are far less likely to bring in ideas from other communities, and as individuals we are too quick to claim that our community is a panacea.

This has just been my experience when interacting with people who are admitted “Clojurians” in discussions with the wider programming community, though, and many of people who I have worked with using Clojure have been polyglots and very much admitted Clojure’s lack of one thing or another. It’s the people who are passionate about Clojure, who identify with it and want to talk about it online, that I feel like lack this sort of shared context that make people from other communities feel like one or both of them are missing something.

[didibus]

@lilactown

I recently received my black belt in Brazilian Jiu Jitsu

I think we need to ask Alex Miller to add a new question to the Clojure survey: “Are you a martial arts practitioner?” I feel like the number of people in this thread who came forward as being one, at this point, is more than the statistical coincidence, maybe there’s something about Clojure that attracts martial artists?

@lilactown

I instead think of a person who practices one of those martial arts, who is ignorant/naive enough to not see see the limitations of those practices and how they fit into the larger context of combat, and a community that encourages this ignorance .

This seems like a very good way to define “fakeness”.

@lilactown

It’s the people who are passionate about Clojure, who identify with it and want to talk about it online, that I feel like lack this sort of shared context that make people from other communities feel like one or both of them are missing something.

Some of my question to you about this are:

1. Do you think this is more true of ClojureScript and front-end web development?

I don’t personally have a lot of front-end web development experience. I’ve done front-end, but it was Flash ActionScript 3, and then it was wxWidget and C++, and then it was Java Swing, and then it was C# and WPF with some Silverlight. Now its only simple server side rendered hiccup with Clojure for internal UX no one cares about. I know I hear a lot of “revolutionary” ideas from the ClojureScript side of things. A lot of them sound like some sort of dataflow inspired programming, some stemming from FRP (either classical or modern). For which I think the JS world and the Haskell/ELM world is also very actively researching and experimenting with. Do you think in that respect, we’ve silo-ed ourselves? Either not keeping up with FRP/dataflow based advancement in other communities, or maybe even with being too focused on the FRP/dataflow approach itself?

2. Do you think this reflects a lack of diversity in background?

I know a lot of the same more experienced developer, including myself, seem to come from C++, Java and C#. As well as sometime, though it seems more rarely, coming from prior FP languages, like ML, Haskell, F# and OCaml. This would to some extent skew our possible perspective with regards to Clojure, everything that is awesome about Clojure over these languages might be its dynamic interactive nature. When your background are these heavyweight static languages, Clojure can seem like this god-like language. Maybe a background in JS, Python, Ruby, Perl wouldn’t have you so stoked on Clojure in comparison.

3. Do you think this reflects a lack of diversity in use case?

Similarly, I do see a lot of experienced vocal Clojurist having more traditional, either enterprise back-end, desktop application, or embedded backgrounds. This could similarly skew us against a lot of the modern more web based world, and some of the more common use case of being a Full Stack dev, or a having clients asking for mobile apps, and online content management systems, or the whole research simulation and data-science space.

[John_Shaffer]

When your background are these heavyweight static languages, Clojure can seem like this god-like language. Maybe a background in JS, Python, Ruby, Perl wouldn’t have you so stoked on Clojure in comparison.

Actually, I worked in Django (Python) prior to Clojure, and what first attracted me to LISP was macros. I found myself writing the same patterns repeatedly, and immediately saw how much code I could eliminate with macros. I searched for LISPs, and what made Clojure stand out was immutable data and maybe STM. Clojure is hugely differentiated from Python in my eyes.

[Richard_Heller]

@lilactown

When I think about “fake martial arts” I don’t actually think of the general practice of e.g. aikido or wing chun.

For me, I do. The traditional arts were developed at a time before guns and people needed those skills on a regular basis to survive. What has happened is that as society has evolved to where that’s no longer needed, the theoretical side has taken over. That’s where you get the fake arts, with people who associate touching somebody with hurting them. That’s simply not how it works.

BJJ, to me, falls half way between real and fake. It was designed to be useful in a sparring environment, not on the battlefield. The Gracies’ favorite catch phrase when they first promoted the art was “the brutal reality of the streets” being that most fights ended up on the ground. I grew up in a small town in the boonies of Ohio. One-on-one, empty handed wasn’t even the brutal reality of those streets, let alone LA or New York.

Applying that to programming, I have a hard time listing any general purpose language as equivalent to fake martial arts. Each language exists to solve a real problem that’s being hit in the real world. Clojure was developed because of Hickey’s experiences delivering products to customers. Same with the other languages, even the niche ones like Rust, Go, Elm, Erlang, etc. The ones that I would put as comparable to fake arts would be ones like BrainF**k or Logo that were designed strictly for teaching or as a lark.

[lilactown]

@Richard_Heller

Applying that to programming, I have a hard time listing any general purpose language as equivalent to fake martial arts. Each language exists to solve a real problem that’s being hit in the real world.

That’s why I think the way you’re framing it is not a useful model for answering the OPs question.

You’re drawing an arbitrary line in the sand where something crosses over into “fake” or “real:” a martial art must be “battlefield” tested and work on the “brutal reality” of the boonies of Ohio. We can argue for hours on the efficacy of specific techniques and practices in various contexts; it doesn’t really matter.

Practicing aikido, wing chun, BJJ, TKD, Mauy Thai, tai chi, Krav Maga, whatever is all fine. What stands out to me are the people who train and are clearly delusional about their own capabilities, and have no mechanism to test their capabilities built into their practice or their community. For some arts, their community hits a critical mass of people who exhibit this behavior where it becomes difficult to take them seriously. I think it’s far more interesting to use that as a way of classifying “fake” martial arts rather than “anything that hasn’t been used in a war.”

Using this lens, you can then try and answer the OP a little bit better; there are definitely different languages and programming communities that make claims about their efficacy, some which have clearly not actually tested their claims. And there are definitely programming communities that are very insular and don’t know really understand how they compare to other languages/communities. This can lead to people deluding themselves about their chosen languages merits, and left unchecked (either by using in production or lots of mingling with other communities), leads to zealotry and delusion.

Not trying to take a pot shot, but to give an example, many of the people over at reddit’s r/lisp fit this description in my opinion. It’s not that Lisp itself is bad, but the combination of an insular community, very few large scale production uses of it, and a sort of legendary history leads a very vocal group of people to the unexamined belief that Lisp is the One True Language™️.

It’s obvious to me that there are some wonderful things that live inside of Lisp, that we all would be better off understanding, but there’s also a lot of tradeoffs and bad design decisions. To me, Lisp falls under the umbrella of “fake [programming] arts”: has some good stuff, but doesn’t really do what it says on the tin.

[Richard_Heller]

@lilactown

For some arts, their community hits a critical mass of people who exhibit this behavior where it becomes difficult to take them seriously.

All of them have hit that critical mass, including MMA. The definition of martial is “of or appropriate to war”. By definition, a fake art would be one that isn’t martial, i.e. not appropriate for war.

@lilactown

Lisp falls under the umbrella of “fake [programming] arts”: has some good stuff, but doesn’t really do what it says on the tin.

Lisp falls under the same umbrella as Kung-fu, Karate, etc. It was useful and powerful way back in the day, but they’ve invented better stuff. Back in the 80s and 90s, Lisp did deliver on what it says on the tin. It doesn’t any more because every language out there has borrowed the useful parts of it.

[didibus]

@lilactown

It’s obvious to me that there are some wonderful things that live inside of Lisp, that we all would be better off understanding, but there’s also a lot of tradeoffs and bad design decisions

I think this is a good point. There tend to be that with the kind of freedom that Lisp provides at the fundamental layer of abstraction, like the syntax of the language itself and its semantics are flexible. This is a weird attribute. Its like metallurgy at this point. You can do a lot and have so many options where you take this, but do you want to train for the sword, the axe, the shield, etc. Yet I think in the Lisp circles, much time is spent deliberating at that level, never going beyond it.

I think one thing Clojure improved over CL is having an opinion at the layers above. Sure, you’ve got macros, you’ve got reader literals, you can take this syntax anywhere and the semantics everywhere.

But Clojure said, these are the best data-structures, we shall make them our basic set of moves: immutable vectors, maps and sets. Lists shall only be used for manipulating and representing code.

We shall agree on common literals, which improves the syntax from the context of those fundamental data-structures we established.

We shall have this common abstraction, the sequence, we shall build many more tools around it. It too shall be central to how we model our data transformation.

We shall embrace the good parts of OO such as open polymorphism and interfaces.

We shall have value equality of objects, embrace multi-threading, choose CSP over actors, and shall target very specific platforms.

Etc.

Basically, it has gone beyond Lisp’s essence and has brought a conversation around the set of lisp functions and macros that make the most sense. It encourages spending a lot of time thinking about those and making sure they provide us value and work well together.

If you think of most other language, only maybe on v0 of the language does the designer spends time thinking and debating syntax and semantics. Once that’s established, rigid as most other language are beyond that point, all the focus turns to the next layer. What are the supprted constructs, and what’s the standard library going to be like. What are the frameworks going to do and work, etc.

Sometimes I feel the Clojure community almost resist this ascent. There’s a large portion of members who still reject the JVM, reject JS, and want a custom runtime. Others who keep thinking about changes to the fundamentals, can’t transducers replace sequences, why is contains not called contains-key, could defn take the doc-string after the arg vector, should we allow reader macros, etc.

Not saying any of that doesn’t matter. But if you look at where other community invest their time and effort, it is rarely at such a low level. Arguably, they have no control on it, and changing that level is so.much effort on most other language. So people focus on the higher level pieces.

I think this is something that Clojure does better than other Lisps, but still worse than most popular languages.

[jackrusher]

I keep trying to look away so I’m not tempted to comment more about the martial arts portion of this thread, but I’m having a fairly strong “someone’s wrong on the internet” moment…

Everyone thinks there’s a magic trick that can overcome a trained opponent. The two most common claims, repeated in this thread, are that eye gouging and groin kicks are those tricks.

If you have not trained in a practical striking art, I promise you that you will not be able to touch a trained fighter’s head, much less the smaller target of their eye. Here’s a video to give you the flavour of how much like a magic trick even basic head movement is to the untrained:

How To Win A Street Fight WIth Head Movement, Learn Simple (But Awesome) Street...

(good stuff starts at 1:38)

In addition to this, if someone is beating your ass the last thing you want to do is raise the stakes in the confrontation. They can gouge your eyes too, and if they’re a good wrestler they can pin you helplessly to the floor while doing it repeatedly and with impunity.

The same applies to everything groin-related.

“No one has won a war with MA since the advent of gunpowder”

(Nasal geek voice) Well, actually… guns are not equipped with infinite bullets, and often fail mechanically on the battlefield, which leads to settling matters manually even in the modern era. This is why CQC (close quarter combat) is still taught to soldiers today.

Of particular interest in this regard is the Russo-Japanese war of 1905-07, in which the Russians were so humiliated by their loss to the Japanese – much of it because of hand to hand fighting – that they sent people to train Judo at the Kodokan so they could create a national martial art. This is the origin story of the Russian national MA and sport called Sambo, which mixes judo, wrestling and kickboxing – that is, it’s MMA in a judo jacket and shorts.

In addition, if you spend too much time reading accounts of trench warfare in WWI, it comes into focus that those not killed by bombs or machine gun fire were beaten to death with shovels, drowned in puddles and stabbed to death during CQC in trenches. Most nations revamped their hand-to-hand protocols around this time on the basis of these experiences.

Likewise, there was enough plain old CQC murder in WWII that most world powers revamped their systems. The English and British forces adopted a curriculum created by W.E. Fairbairn, who put together a mix of Western boxing and wrestling with judo/jiujitsu and Chinese kicking techniques while serving as an officer in the Shanghai police force. If they had created a sportive venue for this system, it would have resulted in a Western form of Sambo starting from the 40s and the Gracies wouldn’t have had a business model.

Modern CQC is now literally MMA training plus weapons-related stuff (see the knife defense video upthread). That everyone who really fights ends up with the same basic vocabulary of techniques and training methods comes down to the sameness of physics and human anatomy.

[Yogthos]

The fact that commercial use of Clojure keeps growing shows that it is at least as effective as other stacks. Business competition is Darwinian in nature, and technologies that don’t work end up being weeded out bacause the companies using them fail.

So, at worst, Clojure is as effective as a mainstream language, but it feels good. I would argue this is a value of itself since happier developers are more motivated and write better cause.

However, I think it’s also worth noting that Clojure is significantly different from traditional languages and has a fairly high ramp up curve because of that. So, the fact that it’s getting adoption despite this fact indicates that people are finding something that’s lacking in their current tool sets. If there was no value in using Clojure, then we would likely not see companies like Apple, Atlassian, and Walmart use it in production for their mission critical products.

To sum up, Clojure is actively competing with other technologies in the wild, and it’s clearly holding its own against them as usage continues to grow, and feedback from companies using Clojure is overwhelmingly positive. Using the martial arts analogy, Clojure is actively competing in the MMA arena of martial arts.

[taf]

… now… first of all… i am a huge fan of your luminus related work …i have been using it for a while now… and i am super happy with it!!! GREAT STUFF! KEEP IT UP!!!

…having said that… the arguments you outline in this post… well… they do seam, to me at least, kinda shaky… AT BEST!

now what do i mean? … well… where to begin?

so… for one thing… to me people always come first… so… to me it is never just about the argument,…NO!.. it is at least as much about the person delivering it… and so… often times… to me… “cui bono” seams like a great place to start… also mind you the following:

Ad hominem | Criticism as a fallacy

so… given the fact that you are highly invested into clojure yourself… that alone puts you at risk to become somewhat less objective… ( socrates was ugly, mind you )

Clojure: a pragmatic data driven language?

well first of all i think everybody has already made really excellent points,… therefore i am not sure if my 5 cents can add anything of value, or if i am even on topic,… so here goes nothing… to me this question is fundamentally one about classification ( pretty much my favorite subject matter these days :-)) and therefore all that can be said in general about classification is valid and relevant in this particular case as well. ( here is the link to a youtube video in which i elaborate on …

…so it feels to me like you are trying to rationalize / justify your own preferences… which then leads to weak / questionable arguments… which you don’t really need to advance in the first place

for example…

@Yogthos

So, at worst, Clojure is as effective as a mainstream language, but it feels good. I would argue this is a value of itself since happier developers are more motivated and write better cause.

this does not work at all!.. you could claim that clojure feels terrible and makes programmers less happy just as easily… you see… in order for this logic to make sense… it has to remain limited to the personal level… hence… this can not possibly hold water for the general case… i.e. this really isn’t convincing at all!

also… there is this huge problem with cause and effect here… you argue… companies using clojure are doing reasonably well, therefore clojure is necessarily at least on a par with other programming languages… which is a HUUUUUUUUGE leap… one that i am certainly not willing to follow… you see… not only is a programming language just one small factor in the extremely complicated puzzle that is the successful functioning / operating of even the smallest of enterprises… worse… it is not even clear… i think… if technological soundness necessarily fosters economic success… now you may say… ohh… but what he is saying is just nonsense… the causal relations are clear as day / could be!.. to which i will reply:… how do you prove to me that smoking causes cancer of the lungs?.. is that obvious?.. you may think so, but it most certainly is not!.. in fact… there have been decades of countless trials… and the definitiv answer / proof did really only come with the advent of modern genetics… because… you see… to soundly proof such correlations is a really tricky business indeed!!!

then there is this notorious problem with feedback… so you argue:

@Yogthos

and feedback from companies using Clojure is overwhelmingly positive.

that means almost nothing at all!!! one of the main problems with it is that the people you ask are already invested in clojure and paying for it so to speak… now… let me give you another example in order to be able to better illustrate my point… suppose you were interested in the effectiveness of psychoanalytic-therapy… so… what are you gonna do?.. well… simple task you say!.. lets just ask the therapists and the patients, what they think of it!!!.. ( …and insurance should pay or not for the costs of the treatment, based on that outcome of that survey?.. ) …so you go ahead and do that… and WHAT A SURPRISE!.. you well get feedback that is overwhelmingly positive!!!.. but… so… does that mean it is effective?.. just because people involved in it like doing it?.. and because they report that it is effective?.. well… personally i do not think so … because… always keep in mind… CUI BONO!.. also i think this example in particular… it can be very insightful… since… you know… we are discussing clojure… and how well it works… but on the large scale of things… nobody really cares about that … on the other hand… an enormous amount of energy has been invested in exploring the effectiveness of psychoanalysis… yet… here is all that wikipedia is comfortable saying about that:

Psychoanalysis | Effectiveness

…now… when i read your post… and felt like i had to reply… i thought i had many more objections that needed to be raised… but now… i am afraid i have already forgotten about most of them… so… i don’t know… plus… i guess i have already made a few critical remarks now already… and also i do not wanna sound too harsh… also… i am really a huge luminus fan!

so… let’s perhaps end with a quote from oscar wilde:

“A cynic is a man who knows the price of everything, and the value of nothing.”

which i personally like to turn into:

a lot of ( cynical? ) people seam to think … or at least argue… that price = value and popularity = quality… BUT I BEG TO DIFFER!!!

so… what does ultimately give value and meaning to our all lives?.. well… hmm… i don’t know … but there is this nice quote from zhuangzi… which is kind of fun to contemplate for a moment or two:

“All men know the use of the useful, but nobody knows the use of the useless!”

---

p.s. i just got a:

Your post was flagged as inappropriate : the community feels it is offensive, abusive, or a violation of our community guidelines.

so… now i am not really sure what to make of that… i have just re-read the community guidelines… and i am not really sure how this is supposed to be in violation of them… so… let me be very clear on this… i think very highly of Yogthos and his work!.. i have also made a few small contributions to luminus myself… i just think that the particular argument i have commented on is not a 100% convincing one… so… well… i don’t know… does Yogthos himself even think of this as being offensive?.. if so… obviously i will apologize right away!.. that was never my intention!!!

[Yogthos]

this does not work at all!.. you could claim that clojure feels terrible and makes programmers less happy just as easily… you see… in order for this logic to make sense… it has to remain limited to the personal level… hence… this can not possibly hold water for the general case… i.e. this really isn’t convincing at all!

Explain to me why people would jump through hoops to use a niche language if they didn’t enjoy using it. After all, it’s a lot easier to get a job using a mainstream language. There’s a lot less effort involved in learning a mainstream language as well since there’s a bigger community, more documentation, and often better tooling available. My argument is that people choose Clojure despite it being niche. Furthermore, empirical data appears to support my argument https://www.itworld.com/article/2693998/clojure-developers-are-the-happiest-developers.html

which is a HUUUUUUUUGE leap… one that i am certainly not willing to follow

I agree that there are plenty of other factors involved in creating a successful business, however if Clojure was a significant determent to delivering working products then companies would fail. We don’t see people using Brainfuck to build their products for example. We’re also seeing Clojure usage in production grow, and people who do use it talk about tangible benefits they saw compared to other technology they’ve used. So, at the very least there is a perceived benefit from people using Clojure. This goes back to the earlier point that if nothing else, at least people find it enjoyable and productive. Here’s one concrete example https://www.youtube.com/watch?v=u-4FiFpkPlQ

that means almost nothing at all!!! one of the main problems with it is that the people you ask are already invested in clojure and paying for it so to speak

I disagree, lots of people talk about specific problems they solved with Clojure, and why it was easier to solve these problems than with other technologies they used.

To sum up, the feedback from majority of people using the language is that they are happy with it. Nobody is being coerced to use Clojure, it’s a completely voluntary activity. Seeing that the community keeps growing, I think it is quite reasonable to say that people do enjoy using the language.

My experience is that developer happiness is a big factor in productivity. There are lots of studies, such as this one, showing that developer happiness is a factor in success. This is one tangible benefit of using Clojure supported by the available data.

There is also no evidence that I’m familiar with to suggest that Clojure has any negative impact on code quality. Here’s a replication study looking at code quality in different languages, and Clojure clearly isn’t an outlier in any way.

[eccentric_j]

It seems we have a few different arguments going on.

Is the Clojure language like a “fake” martial art?

• Is it as effective or more so than what you commonly find out there?
• Clojure seems to be developed with a very specific vision in mind. Does it make it super effective for problems it’s intended for or does that get in the way of long term, widespread reach? (Like catch wrestling, seems effective but very specific)
• How can we quantify effectiveness?
• Is Clojure more like MMA incorporating many practical techniques from the languages that inspired it?

Are we like “fake” martial artists?

• Have we created a bubble for ourselves where we feel Clojure is the best, only true language because it’s what we use, what we enjoy, and where we spend most of our time with?
• Are we as a community at large learning from other innovations and incorporating what works or are we dismissing anything that doesn’t come from within the Clojure community?
• Are individual Clojurists exploring other languages and solution strategies to learn alternative approaches to incorporate and evolve our work or are we perhaps unintentionally rewarding loyalty and devotion?
• At large does the community respond to criticism constructively and openly, or do we become overly defensive, dismissive, and make excuses?
• Do the leaders of the language\community cultivate a healthy give and take relationship with the community or do they act above questioning and dismiss any attempts to do so?
• What can we do to keep our egos in check and make sure we don’t fall into this trap?

Comparisons between MMA and traditional martial arts?

• Unavoidable territory considering I invited the comparison
• Not what I’d like to focus on

My Thoughts

Is the Clojure language like a “fake” martial art?

• No. It has practical value to the common problem spaces out there. In many cases it improves upon what traditional languages and approaches can offer. Often solutions take less code, and significantly less boilerplate to get there.
• There’s room for more discussion on how to measure effectiveness but those articles like real-world example comparisons are a great start https://medium.com/dailyjs/a-realworld-comparison-of-front-end-frameworks-2020-4e50655fe4c1.
• Clojure’s use in production, growing popularity, and developer happiness are not the strongest proof here as fake martial arts can also be used in production (for instance some fake martial artists end up getting to train police officers and military personal in demonstrations which is scary to think about) and grow in popularity and be fun to learn\use.
• I see where @Yogthos is coming from: Successful companies using Clojure may suggest that it’s effective enough to solve many business problems out there but I see @taf’s counter-point that it’s hard to attribute directly to the use of Clojure with so many other factors involved.

Are we like “fake” martial artists?

• I think we can agree we are not like a no-touch martial art selling something that is completely ineffective.
• At worst we can perhaps be like a dedicated traditional martial artist convinced ours is the one true art
• I felt @lilactown’s answers which gets into more detail about that comparison: Mainly that we narrow our focus to one discipline then convince ourselves its the only correct path. When talking to non-Clojurists I know I have come off as over-confident and arrogant in the past so I need to keep this in mind.
• I liked @seancorfield’s suggestion of learning a new language every year to keep up with what’s available.

Comparing traditional martial arts to MMA

• Looking at the video linked in the OP as well as similar ones, the traditional fighters are not losing due to the rules or from being held back employing more lethal strikes. They simply lack the skill to attack, defend, and move with another highly trained and experienced fighter. They are consistently outmatched. In many of these cases they were the ones who issued the challenge to the MMA fighter in the first place. Especially in the case of Xu Xiaodong.

[eccentric_j]

One last thought:

A friend sent me this which I felt had a beautiful, relevant quote to it:

Why I use typed functional programming

[…]
The tool molds and is molded by it’s user. In my experience the same happens for programming languages: the usage of a specific programming language will mold it (the user will extend it by creating scripts, libraries, blog posts, etc which will influence the evolution of the language itself) and the language will mold the user by influencing the way he thinks about problems, therefore creating a virtuous or vicious cycle between the user and the language.
[…]