Slashdot Mirror
Ask Slashdot: Should I Move From Java To Scala?
"Scala is one of the JVM languages that manages to maintain a hip and professional vibe at the same time," writes long-time Slashdot reader Qbertino -- building up to a big question:
One reason for this probably being that Scala was built by people who knew what they were doing. It has been around for a few years now in a mature form and I got curious about it a few years back. My question to the Slashdot community: Is getting into Scala worthwhile from a practical/industry standpoint or is it better to just stick with Java? Have you done larger, continuous multi-year, multi-man and mission-critical applications in Scala and what are your experiences?
The original submission asks two related questions. First, "Do you have to be a CS/math genius to make sense of Scala and use it correctly?" But more importantly, "Is Scala there to stay wherever it is deployed and used in real-world scenarios, or are there pitfalls and cracks showing up that would deter you from using Scala once again?" So share your experiences and answers in the comments. Would you recommend moving from Java to Scala?
The original submission asks two related questions. First, "Do you have to be a CS/math genius to make sense of Scala and use it correctly?" But more importantly, "Is Scala there to stay wherever it is deployed and used in real-world scenarios, or are there pitfalls and cracks showing up that would deter you from using Scala once again?" So share your experiences and answers in the comments. Would you recommend moving from Java to Scala?
https://www.quora.com/Is-Twitter-getting-rid-of-Scala
Quote "I can't answer that, but I did attend lately a session by Raffi Krikorian, who was VP Platform Engineering at Twitter and one of the people responsible for introducing scala at Twitter.
He was asked about scala, and said that if he would have to choose again today, he's not sure he would go with scala.
The argument was that scala introduces a big learning curve for new developers. Because of its complicated language features it can become hard to read. So at Twitter they are trying to not overuse the complexities of the language, so the main benefit they get from it are lambdas. Which is now basically available with Java 8. So the overhead of developer training might not be worth the benefit."
They are in it just for the monies. It does make me seriously sad, and one of the main reasons I am quitting my job.
But I kindof believe that a lot of workpaces are like that.
Then figure out for yourself if you like it or not. If you're going at this from a PHB perspective just stick with Java.
Scala is fine/fun. It's sufficiently robust in terms of having evolved a reasonable solid foundation of prevalence and documentation and community, and seems likelier to stick around in the longer term than some of the shiny underdocumented hype stuff like Go. (I like the shiny well enough, but at my job I code with an eye on the longer term 5-10 application lifespan and require a certain critical threshold of established foundation and community.)
You should see though, if java 8 picking up lambda suffices for your purposes and functional programming interest. It's not full blown functional programming the way Scala is, but it's reasonably powerful and solves various problems and design pattern warts.
Oreillys Java 8 Lambda by Richard Warburton is well written and a solid reference / learning experience for anyone with basic java familiarity. Read it a few months back and recommend it.
You should switch to Rust. No wait, Swift, er no, Ruby, er no. Don't worry about the flavor of the year language.
Learning a new language, especially one which will make you rethink what is and is not a computer program and how programs should and shouldn't be, is always a good thing.
At this point in time, you might want to look at Kotlin. It offers a syntax improvement over Java, good tool support, compatibility with Java and a simpler transition coming from Java.
I don't have a strong opinion about Scala, but the answer to questions in the form of "should I Move from Java to _____?" is almost always "yes" (for values of _____ not including PHP, VB*, or other asininities).
Dewey, what part of this looks like authorities should be involved?
Still can't figure out why java exists... It is not just that the JVM is bloated but the language itself is terrible.
If you worry about this kind of thing, then you are a worrier. Lighten up. You will look back at this question and think that you were a nob to ask such a thing. An older you will know that the language is transient and that what you can do is the most important thing. Learn lots of languages as you go and pick the right thing for the right job when you need. See between the lines between the lines.
It's the language all major businesses use.
Does Scala offer automatic error correction? Keyword highlighting? Auto-completion? Variable indent colocation?
I don't know where Scala is, but Java sounds like a nice place to live.
For a specific project - look at the ecosystem of libraries and tools, and what you want to accomplish. One project might be easier in java, another in scala.
For a career - look at jobs in your area. Are more people hiring for java or scala? You can learn both of course. Rust is also worth looking into.
But scala is just a language. You don't need to be "math genius" to use one language over another.
Canada
For what it's worth, I'm coming from a Java & Python background but now working on a project deployed in Scala (it's all centered around Spark, which is written in Scala). A small portion is in Java because the front-end app, which is written in JavaScript (I don't care for that but I'm not on the front-end team) and utilizes a shared library. I quite like a lot of the conveniences offered in Scala that I can't figure out how to do in Java 8.
I have a PhD in CS and have coded in many many languages.
Difficult: Yes, I find that is the most difficult language I've ever coded in, but I really enjoy it. The difficulty mainly has to do with the type system, the compiler, and what I call Shiny thing syndrome (STS). When first learning I found occasional surprised in assignments because I had the same types on the left and right hand side, but did not. When examining the types, one would observe a page describing it. This can cause frustration for the novice. The compiler messages and the documentation have both improved immensely in recent years, so this is not as bad a problem as it once was, but still, the documentation is not a gentle guide for the initiate to understand the language. Finally, STS. There are some aspects of the language that seemed to have been simply shoe-horned in, often syntactically. That is, there are many multiple ways to do the exact same thing and all where shoved in because they exist that way and were a shiny thing in some other language. This hurts the language in my opinion.
Enjoyment. I find that when I am coding in Java or other languages I miss features of scala. I have grown to prefer scala over java, which I didn't initially think that I would. I find that I can write a lot of code for 30 minutes in Java or I can sit on my hands looking at the screen for 25 minutes and write for 5 minutes a beautiful piece of code that does the same thing with Scala. The code has an elegance and beauty to it. Actually I don't think I stair at the screen all that long anymore but switching to functional was initially quite the paradigm shift for this old fart.
Consequences ( Scala is not without its issues):
1) The difficulty of the language makes it very difficult to be productive with novice coders on your team. Don't do it.
2) Some aspects of the language: e.g. Macros, implicit parameters, implicit types, can make for elegant code, but can also make your code look like magic that will baffle your (less than stellar) team member. Use with caution.
3) You will think different after mastering it, that is a good thing. Nothing special about scala, you should learn new languages frequently for this reason.Scala will help you.
4) Don't do it because it is a hot new language, don't do it because you think it will solve a problem better than another or you'll make more money, do it because you love to code and you want to explore using a new tool set. Do it for the fun. I enjoy coding in Scala much more than java, and the akka actor framework is great. But you will find many analogues to the actor framework (example go routines, rust channels etc)*, but it all addresses the difficulties of multi-threading, which are somewhat cumbersome and error prone in Java.
*Yes I know they are different, before you pretentiously lecture me on the difference, please realize that I am comparing not contrasting here. They all have the same goal to approach simplifying life in the multi-threaded environment.
Anyhow, my advise is pursue learning scala with vigor and wild abandon. I'd also recommend go-lang and rust, they are cool also. After you learn them then decide on the tools that you want to work professionally in. You will not be harmed by the effort.
Scala has achieved critical mass, it has shown steady growth over the years and will likely continue. It is entirely possible it will never become as big as Java but that should not be the requirement, it is plenty big enough you can count on it.
I have been developing large scale projects in Scala for the last 6 years and I can't imagine going back to Java now. Scala makes it easy and fun to write good correct code.
Scala is boilerplate free, it feels a bit like your favorite scripting languages yet with compile safety a powerful type system and lot's of help from IDE.
Obviously Scala supports Functional Programming which is essential as everything becomes multi threaded and/or distributed. Scala makes it easy to write functional code and is immutable by default, yet it isn't opinionated and you can use other paradigms when they make things easier/faster.
It's fun to write, you don't have to be a genius to use it, though with weak members on your team you will want a strict style guide. I found using Scala is a selling point when recruiting top talent, even those who never used it. Those who have used it, especially coming from a Java background are instantly hooked.
This was verified again in recent Stack Overflow developer surveys where Scala came out to be a very loved language, nearly everyone who tries it falls in love.
I highly recommend
My personal opinion:
If you're sick of Java's verbosity and various problems, think about Kotlin. Kotlin works really well, has fantastic IntelliJ support, runs on Android, and has fantastic Java interoperability. We already use it for commercial projects where I work.
Most importantly, though, it fixes the billion-dollar mistake: null. Nullable values are handled beautifully with no overhead.
It's very much like Swift to my understanding, but it's for the JVM.
https://kotlinlang.org/docs/reference/comparison-to-scala.html
If you want to schlep all the way from Indonesia to Italy, sure, why not.
systemd is Roko's Basilisk.
In my humble opinion..
Scala is great for scripting, iterating, researching, and playing around with various concepts. The downside is that its not binary compatible between major versions. There are some stability issues in production as well, some exciting rabbit holes of error stacks.
Java is like herpes. Its everywhere and is not likely to ever be gone completely. It is also rock-solid stable in production. The biggest cost is that you have to write it in Java. If only it was like scripting in Python, then this would be a great language. Incidentally Jython is not great for other reasons, but thats neither here nor there.
I don't have a particular opinion, other than the common concerns about its performance and resource utilization. But I tend to code at the traces anyway.
007: "Who are you?"
Pussy: "My name is Pussy Galore."
007: "I must be dreaming..."
First, background: I have been using Java at work, at least part time, since 2005. I started getting paid to write scala since 2012. I've definitely ran large, critical applications in Scala: I am running some right now.
Scala is a far more featureful, complicated language than Java is. A lot of what it gives you is really very high quality syntactic sugar (case classes, lambdas, pattern matching), but the one thing that sets it apart is its type system.
The trick is that nothing forces you to use Scala as if you were using Haskell instead: You can use it as a more sugary Java, using the extra type system fun sparingly. Restraint is the name of the game here, and also the reason some people have Scala horror stories: A company decides that Scala sounds great, and then hire some hotshot scalaz committer to teach everyone else how it's done. Then your codebase is full of operators that look like line noise, every class extends a base that comes straight from category theory, and half the developers say 'screw this, let's rewrite it all in Go!'
There is value in the category theory, and using arcane libraries like cats or shapeless, but 99% of the time, you don't need to: Just like back in the 90s you had to stop people from overusing OO design patterns, or their code will end up looking like Spring, Scala shops have to remind people to do the same when it comes to higher kinded types, hlists and concepts out of category theory. You really don't need any of that to use Scala successfully. Just ending up in a world where you typically don't need either a mocking library or any dependency injection nonsense is more than enough to switch. (Curse you Rod Johnson!)
The one thing where I would make people spend some time studying is in basics of functional programming, the very first of which is to learn to remove side effects from code, and clearly separate code that changes state from computation. Chances are you were doing some of that already in Java if you were hoping for a good unit test suite, but it's more important in Scala
Career wise, the more is a no brainer IMO: If you write Java, you are one in a very large pool of completely generic candidates that can use Spring and Hibernate to do something super boring. In Sala, you enter a smaller pool that most of the most average Java developers will never try to enter, so, on average, the job will be more interesting, and the pay will be higher.
Choose one.
Have gnu, will travel.
Programming should never be hip or professional.
It should be hard to read and cryptic. Brainfuck 2017
Having used plenty of Java in big-ish teams over the years - and mind you, having never used any other JVM languages beyond simple tutorials or scripts - I can imagine that Scala's learning curve might present a problem. Kotlin, on the other hand (as far as I can tell from my admittedly limited experience) adopts many of the best syntax features of alternatives like Scala and Groovy while keeping things simple enough for pretty much any existing Java developer to use right away. On top of that it does not introduce any new APIs or concepts like actors to get a grip on - as such cross-compatibility with existing Java code is 100% out of the box (this was of course a big factor for the JetBrains folks who are using it to develop the future of their IDE platform). And even though Java 8 is a huge advance in terms of functional programming support, it feels like a more natural fit in Kotlin. Essentially I think Kotlin is something like "Java 2.0", or what Java could be if they were willing to throw backwards compatibility out the window. :) At the same time it's dead simple to learn in its entirety in a short period of time, as opposed to Scala's huge feature set and learning curve. Scala may be the "better" language overall, but Kotlin seems like the more practical choice, especially for teams that have no Scala experience as of yet.
If your team doesn't have enough people familiar with Scala to answer this question already, not to mention you're evaluating languages by "hipness" or popularity... then the answer is "fuck no, you should not write your mission critical software using that tool".
That's not to say you can never use a new or unfamiliar language. But start small. Write a prototype or small scale project and integrate new ideas slowly, in a reasonably safe setting where failure isn't a total disaster. You'll build experience and get a sense for whether it serves your needs or not.
One of the surest roads to ruin in software development is becoming all starry-eyed over a novel language or platform that you think will solve all your problems while cooking a steak and giving you a blowjob. It usually doesn't turn out that way. The main exception to this rule would be if you're in an inherently risky business where there are no known solutions and you have to bet big on something to get in the game. Almost all business software is not that way, it's paint-by-numbers stuff that can be done in any language.
The bitter lesson I've learned over the years is that the larger the team, the simpler the tool set and the less clever the implementation must be.
And it makes sense. You pretty much have to target the 10th percentile programmer in your organization or your going to have your systems ruined over time.
In a small organization, you can probably hire selectively enough that your 10th percentile programmer can handle Scala. In a large organization (like Twitter is now), not so much.
We've got a system that's 13 years old, with 4+ people, some stronger than others, making changes and it's held up fairly well.
With all the Scala hype, people neglect to point out that Scala is NOT compatible with Java; alot of libraries and tools have to be rewritten to work with Scala. This is why LinkedIn dumped Scala, Spring dumped its Scala adaptation and more and more companies are dumping Scala. And for all its hype on 'functional programming', you can do the EXACT same thing in Java and Groovy with 100% compatibility. In fact, every Java class converts 100% to Groovy; take any Java class and change the '.java' extension to '.groovy' and it will compile without issue. The same CANNOT BE SAID OF SCALA! This is because it is not compatible with Java and requires Java rewrites in order to be compatible.
This is my sig. There are many like it but this one is mine.
You want a feature, you know the most programmers use Java, why would you stray off the main java road to get that feature? For most projects, you just implement any special bits as a base of classes and move on, you don't change the whole programming language.
Twitter isn't really complicated, it's a fraction of the complexity of even the font renderer in the browser it runs in.
"As far as language features, pattern matching, expressive types with inference, var/val immutability are all huge helps to write more concise programs."
You wouldn't use the built in pattern matching. Using a stock third party chunk of software is fine if the science hasn't changed there, but pattern matching is rapidly changing to neural network based anyway. Since its a core piece of their work, and the science is progressing, and they need to keep up with that change, not try to use third party code. It makes it worse if the code in question is built into the programming language and not a third party library.
"There are more CS-y features like tail recursion, laziness, um.. monads (any typelevel library)"
The chains of code that bypass in nulls, aka Lamdas, monads etc. are just shit programming. Deal with the error where you made the error. Do it clearly and well commented. Making compact code isn't useful, the computer has plenty of space to hold your code.
Since *when* has being "hip" been an attribute, much less a desirable one, of a competent language? The only friggin' professionals who speak in those terms are marketers.
PhD in CS and chasing latest hotness? You've managed to waste your time in multiple dimensions.
Definitely no.
One of the interesting aspects of Scala is that you can transfer many of the skills acquired using OO languages like Python or Java.
You might find blog some posts and discussion in Scala where the discourse is very technical and presupposes a lot of knowledge of Typed Functional Programming but that doesn't mean that's the common way in which Scala programs are written.
It rather reflect the fact that people like to talk about interesting and novel approaches as opposed to the "boring" mundane things that comprises 90% of the experience of writing code in any language.
>> "is it better to just stick with Java?"
Hell no. I mean, you can learn another language and still do Java when / if needed. Scala provides a nice bridge between the more mainstream OO paradigm and the more principled FP way of writing software like Haskell.
Scala has a pattern of loosing core/active contributors on not amicable terms and the community is not always especially friendly.
My experience there had me questioning whether the community would be able to keep Scala's foothold in the programming world or if other languages would out pace and then replace it.
I'm a mediocre Java programmer, and I was once given some Scala code to look at, with a view to making some minor changes. I just got annoyed - seemed like the code author was more interested in showing off how clever you could be in Scala rather than writing something that got the job done and was MAINTAINABLE. And when google'ing for help on Scala I got the distinct impression that many in the Scala community were more interested in showing how clever they were than actually helping poor noobs. ..Impl classes, and naturally no comments, not even in the class headers. But the code that has no bugs is the code you *don't* write, and Brian Kernighan's old quote about "..debugging is twice as hard as writing the code in the first place.." is still true today. And most of all - keep it as simple as possible.
So if I was managing a development team that had to write code that both worked and was maintainable I'd stay away from Scala. You have a responsibility to the company that's paying you to produce code that can be maintained/modified by less-skilled, and usually poorly-paid, maintenance programmers. (Obligatory car metaphor: Writing super-clever code that can't be maintained is like selling someone a high-performance car but with no supply of spare parts.)
Of course you can write crap code in any language - I've seen Spring/Java code with hundreds of useless empty classes mirrored by
I have a PhD in CS and have coded in many many languages.
In other words, "I have worked a lot in fake environments in many languages".
You got a PhD in part because of a language that is controversial, and you consider that a win? The value of a CS PhD just dropped a few points.
I too have coded in many different languages. Tcl/Tk was painful, but doable. Javascript was painful and not doable. Sed, awk, bash,various assembler, C,, C++, Java, Perl, Python is a subset of languages I've coded in.
Never used Scalia, probably never will. I'm old, odds are both against having the option, and me saying "not saying this is bullshit, but I'm pretty sure I saw it come out of the bull and hit the ground".
I've been around enough years to hear FORTRAN, Cobol, C, C++, and Java all maligned by small minded fools who couldn't program their way out of a paper bag because their IDE doesn't have a plugin for it. Suck it up guys, the next iteration of Algol-68 will be here any day now. And it'll be great.
Get the fuck out of the Java world. I'm tired of seeing whiny little shits bitching about how uncool the language, or doesn't support the latest buzzword paradigm. Really quit and go to your hipster language.
I've made a shit load of money fixing crap because hipsters were more interested in doing cool stuff than doing boring shit like writing maintainable code that reliable and meets requirements.
So please move to scala with the other hipsters and get the fuck out of the Java world.
Given you're question, you should move away from anything with a keyboard.
You got a PhD in part because of a language that is controversial, and you consider that a win?
I'm sorry, in what part of his post did he say that?
There are a zillion fad languages out there. Each (presumably) excels at something, but most languages that are not in widespread general use will usually suck at anything outside the core competency of that language. Second-tier languages also have smaller communities developing tools and components, making them less desirable. Finally, if you ever need to hire programmers, you seriously limit your pool of available candidates if you lock yourself into a language that is not in widespread use.
My advice: stick with mainstream languages like Java, C#, C++, JavaScript. All of these languages are powerful in their own way, and there are lots of people who use them.
1) Do you need a degree or to dive into the math to make effective use of the language? No. Like any programming language you can just learn the patterns and apply them. That said, like any programming language, if you learn the math behind why it works you can make more effective use of the language. (You are probably using monoids, functors, monads, and maybe applicative functors in any large program. Not knowing what those are doesn't mean you aren't using them.)
2) Would I recommend switching?
I having been programming professionally for 31 years. I have been programming Scala since 2010. I have taught about a dozen people the language. Much like, "Should I quite my day job to put all my time into my startup?", the answer is probably, "not right now". If you can get the same or better pay, under the same or better conditions, then obviously yes, make the switch. Otherwise if the language interests you (same answer for the startup) then work on it in your spare time with your day job giving you the security you need to expand your horizons. As a programmer learning new languages will make you a better programmer. Learning languages like Scala or Haskell which lean so heavily into functional programming and their higher-kinded type systems will definitely expand your knowledge. Additionally you'll then be able to decide if a switch is worth it FOR YOU rather than relying on getting a useful answer from a infinite number of monkeys banging on an infinite number of keyboards.
All that said no company would pay the price I would demand to code in Java again.
I got stuck maintaining a bunch of Scala code at one point, and I'd say "no thanks." Why?
The code wasn't any more error-free than any other code, but it was an order of magnitude more difficult to maintain. It also didn't seem to speed up the development process any; the devs were just as late as they were without Scala.
Scala developers are also expensive and hard to find, two things that make finding a "Scala maintainer" a difficult task.
Unless you're willing to invest in supporting it, I'd say no. If you want a functional language go to a real one, not one built on top of Java. And be sure that the use case for it fits the language.
Clearly an advertorial.
For Android use Java, for Windows use C++ or C#, for Linux C++. Scalar's been around for 13 years, it isn't the basic for any development platform. It's a bit clumsy as syntax goes.
"yet it isn't opinionated and you can use other paradigms when...."
Yeh, same claims for Occam, yet it went nowhere either. Crap like this comes and goes. After 13 years this has gone already.
No question there's a learning curve, but you don't have to be a genius to learn Scala and use it effectively. Is Scala there to stay? Yes. I've used it successfully at TraceLink, Inc and CiBO Technologies, Inc and am a big fan. Scala is richer and more expressive than Java and eliminates annoyances like checked exceptions. The key is the principal of minimum power (use the smallest hammer that gets the job done) and some consistency in style across the team. If people go meta-nuts with advanced language features, the result can be spectacular failure. If you use the language right, it's wonderful and you can write some great code quickly.
... as with any language or platform, Scala is worth looking at even if just to open your mind to alternative ideas.
I first looked (and deployed with) Scala having discovered it's original affinity to Erlang's asynchronous message-passing capabilities. However, with Scala's move to Akka, the original Erlang-like simplicity was lost - although I believe that Akka has improved since then. As others have mentioned in this thread, Scala does unfortunately provide the means for programmers to create needlessly-complex and hence unmaintainable code, so this requires careful governance. Personally, my dev team switched from Java to Groovy with great success - and I believe a switch from Java to Scala would not have yielded the same levels of productivity from the team. Regarding functional programming - again, explore (if you haven't already done so), but bear in mind that the JVM was never really designed to support functional in the same way as the Erlang VM, so keep it simple.
- c.
S'not actually in the post but he nose.
It's projection. He feels he needs to exert dominance and show that he is better than people with doctorates which is kind of entirely pointless due to different people working on different things.
In other words, "I have worked a lot in fake environments in many languages".
Or, to rephrase what you said "I have my head permanently lodged up my arse".
You're welcome.
SJW n. One who posts facts.
I think there are better choices to invest your time in. javascript is getting more and more mainstream for frontend. Learn Go or python if you want to work in a startup.
No
He gave you some sense as to why he's experienced in this area. You can choose to believe it or not; you can listen to his opinion or not. Responding snottily, to things he didn't say, seems like a less than optimal choice. Put another way, I got a lot more interesting info from his post than from your retort.
First - there was an extremely obvious attempt at a joke (which you appear to have taken seriously and appear to require it to contain information) hence the "Responding snottily".
Second - how can you get any more snotty than putting down all doctorates as working in fake environments? I really do not see how that does anything other than reflect on the person who is trying to devalue the work of a vast number of others while blowing their own trumpet.
Stitch up your enemy? But seriously, programming is nothing like warfare. It is more like crafting a bespoke garment for a gorilla who believes himself to be a six legged, two headed flying dragon. And cleverer syntax and multiparadigm languages make it easier to confuse the gorilla.
No!
you have no business trying to have an IT career. The world has a better place for you as a plumber/welder/hvac/general laborer.
Should i dress white or black today? Should i wear a fancy shirt or a hoodie when going to work?
So no, unless you have a really compelling reason (like: the project i am currently doing sucks in java and would be very nice in scala), stay with what you know.
I never evaluated Scala, but when deciding between Clojure and Scala for a personal project I recalled a video on YouTube where Steve Yagge said it was scared by the complexity of Scala (probably not the exact words he used, I watched the video many years ago).
And mostly because I was fond of Lisp inspired languages (did we call Clojure a Lisp dialect?).
I've programmed in more languages than I want to count. In the end it is all code and what matters is the market.
Code I like:
Machine code (ARM core is interesting)
Pascal
Python
But what I like isn't important - it is what will provide work.
A better question is to ask yourself what the return on investment is on learning a new language?
I thought a lot of the stuff I learned would make me more valuable than it did - most of it is obsolete now or pays very poorly.
The other thing to consider is with a lot of code work going overseas would it be better to look at stuff that can't leave?
Isn't that how the tech world operates these days?
If you make it possible to attach methods to objects at the lowest levels, then you usually don't need to pass lambdas.
Take a GUI push button, why can't one simply define an OnClick method for a given button in Java? That shouldn't be asking to much. Simply blur the distinction between class and object, or make it a class-definer option. Java simply has a limited OOP model.
Can someone present a use-case in typical work coding where lambdas are a must, or at least a huge code savings?
Table-ized A.I.
Try Ceylon instead of Scala. It's significantly simpler and cleaner, it's modern, and it has perfect Java interoperability. It's actively developed by RedHat's enterprise Java team.
The C and C++ jobs are few and the applicants for those jobs are innumerable.
I have a PhD in CS and have coded in many many languages.
In other words, "I have worked a lot in fake environments in many languages".
Your ego must be very fragile to be trigger like this.
You got a PhD in part because of a language that is controversial, and you consider that a win? The value of a CS PhD just dropped a few points.
That's not what he said, but obviously, it is your right to put words into his mouth. Keep banging that strawman, I don't judge.