Firstly, I’ll tell you what you shouldn’t do to become a good programmer. No matter what anybody tells you, if you spend too much time doing any of the following things it might improve your skills a little, but you will never be a good programmer:

• You won’t become a good programmer by just reading books.
• You won’t become a good programmer by memorising code and algorithms. Programming is about thinking not about remembering. You can have the best memory, but if you’re not thinking for yourself you’ll NEVER be a good programmer i.e. we have computers and the internet to remember things for us, so there’s no need for you to remember anything - you just need to know where and how to find the information you need.
• You won’t become a good programmer by writing single functions and algorithms from the books you read i.e. writing stupid bubble sort functions and similar useless algorithms.
• You won’t become a good programmer by testing other people’s code e.g. whether testing software by using it or writing unit tests etc.
• You won’t become a good programmer by reading and debugging other people’s code. This might help in the short term, but only if the other person’s code is well written so you can pick up some good habits, but using bad code as examples will teach you bad habits that you will ultimately have to unlearn. In the long term spending too much time reading and debugging other people’s code will be detrimental to your growth.
• You won’t become a good programmer by allowing others to micro manage you … because again programming is about thinking for yourself.

There’s only one way to become a good programmer: you have to take on a project and start it and finish it yourself from beginning to end. Don’t focus too much on reading books, syntax, algorithms and functions i.e. don’t focus on details at the beginning. Simply sit and think about an app/system you’d like to develop for yourself … something you’d really enjoy building and using for yourself. Ask your friends/family/lecturers for an idea if you need to, but you must start the project from scratch and finish it by yourself from beginning to end. Once you’ve gotten the idea, keep the idea in your head and be passionate about finishing it … from there everything will slowly start to come together. You will have features in your mind that you want to implement at which point you will start researching how to implement this or that. It’s only at this point that you should pick up a book or search the internet for answers about how to implement this cool feature you’ve thought of doing. As your app/system grows you will slowly by yourself start thinking about writing cleaner code to maintain it in the future to make your own life easier.

It is only through the process and struggle of bringing your own idea to life that you will learn how to become a good programmer. You should see yourself as an artist, not just as guy who writes code to get it to compile and run. If you’re only working on someone else’s code, or only reading books etc. you will lose your motivation very quickly and you will never find or utilize your talent.

Step 1: Find out what skills are companies looking for.

Reverse engineer!

Firstly find out what skillset companies expect you to have.

The best way to find it out is by visiting popular job listing sites.

Here is one such listing I got upon searching for the keyword “Python”:

As you can see, Python alone isn’t the required skillset.

Companies expect you to know other technologies along with it as well.

For example, in the above listing you are also supposed to know Pandas, SQLalchemy and Django.

My recommendation is that you view other job listings as well and note down all the essential skills which the company demands.

Don’t worry if you do not possess or are not an expert in those skills, your job for this step is to just get an idea about what companies expect in a candidate.

If you open up a listing, there will be more details provided about the skills as well as the type of role.

Step 2: Classify the skills.

Once you list out the skills form the job listing site, it’s time to classify them depending upon your level of expertise in them.

Make 3 columns on a sheet of paper and classify them into these 4 categories:

1. Completely unknown: This column would consist of all the skills which you have never learned. For example, if you have never learned Pandas, put it under this column. All the skills under this column must be learned from scratch. You could start learning them via YouTube videos or maybe a course.
2. Little know: This would consist of those skills which you know the basics of but have never dived deeper. Your job is to make sure that you learn more advanced concepts from these technologies. To learn more advanced topics, I would highly recommend that you prefer learning from the documentation as there wont be many YouTube videos or courses on such advanced topics.
3. Skilled: This should consist of skills that you are good enough with and have decent experience working with. Once you are skilled enough in any technology, the best way to test it would be to build a project using it. For example, if you are skilled enough with Django, just try making a complex web application with it. You may start with a basic version of the web app but eventually start adding more advanced and complex features.

Once you complete this step you should become aware of the skills you lack and the skills you possess.

Let’s now move on to the next step.

Step 3: Learning.

Once you know what to learn, you can start learning it.

However, the learning method would completely depend on your level with the skill.

Learning as a beginner:

If you are a complete beginner and want to learn from scratch, then I would highly recommend you to read this article which lists some useful resources to start learning Python.

As a beginner, YouTube videos and Udemy courses are your best bet to quickly get started with any technology.

Learning as an intermediate:

You should strictly skip YouTube and other courses and instead learn from the documentation as it is a much efficient way to learn.

Skip the basics and move towards more advanced topics in any given technology and make sure you learn it in depth.

You may refer to some website articles if stuck, however stick to the docs as far as possible.

Learning as an expert:

If you are an expert at something, you just need to show that off.

And what can be the best way to show off your skills other than building your own project.

Make sure to build a complex project around any simple things. You can pick simplest of the topic like a Todo app and design advanced features around it.

If you have a complex project idea in mind, just go ahead and pursue it.

Step 4: Set targets and a schedule.

Don’t just learn without setting a goal or a target, if you do so, you will be stuck learning a simple technology for months and would be nowhere.

Instead, set a goal/target to learn X technology in Y time.

This will ensure that you wont waste time and would be productive throughout the learning period.

If you are a graduate and are not working elsewhere, you have plenty of time on your hand, hence make sure that you make the most of it.

If you are a college student, wake up an hour early to learn.

If you are a working professional, it would be quite tough to manage a job and learning on the side but If you be stingy with your time and energy, you should be able to squeeze out some learning, especially on the weekends.

Step 5: Apply for jobs.

Once you are confident that you have enough skills, you may start applying for positions from the job listing site.

Be careful though, not all jobs on such sites are good. A lot of them are just garbage and would expect you to know almost everything and would pay you peanuts, hence make sure you stay away from such listings.

Research a bit about the company, if possible try connecting with some existing employees on linked in and try to gauge their experience.

If you are a beginner, I would advice that you focus on the company as opposed to the position.

Once you shortlist the good listings, start applying to them and be patient.

Remember that they are bombarded by CVs from multiple other candidates and hence it might take a while to get a reply back from them.

Make sure to keep learning and upgrading your skills as you keep sending proposals to companies.

1. Dive deep into details. If you learn Java, try to understand not only syntax of the language, but also how it works under the hood - how JVM works, how objects are represented in memory, how code is translated into machine commands, how CPU (or something else?) handles I/O operations. Working on web application - tend to learn not only framework, but also protocols, how packages are exchanged between client and server, how encryption algorithms work. However, don't try to get all in once. Start from high level, make it work, then go into details on stuff that look like black box for you. Good understanding of low-level concepts will speed up you future learning.
2. Always ask “Why should it work in this way?” Follow, but don't blindly trust best practices, find out what advantages make them best.
3. Work on different tasks. 10 years of experience doing the same work is only 1 year repeated 10 times. Change teams inside your company, change companies, work on pet projects in your free time. It's not about cool new technologies (if you understand basics, you'll see that they are not so new and not so cool), it's about trying yourself in different roles in different fields - tend to work as a coder, architect, tester, try to establish a new process in your team, talk to customers - be infolved in full cycle of software development.
4. Work with clever engineers. And listen to them.
5. Never think you are a great engineer. You should always look for your weaknesses, be unsure in your decisions and listen to other people. Be right in more than half discussions is great, be right in more than 90% is awful (because you either wrong and don't see that or work with people you can't learn from). Too high self-esteem is an enemy.

Generally you need a four year computer science degree or professional experience culminating in senior engineering work at product building companies.

Box hired me to do engineering work including writing Scala although I’d never seen the language before.

Amazon hired me to write Java which I’d used once but didn’t admit to on my resume.

Microsoft hired me to write C# which I’d never used before.

They did that because given a little coaching competent engineers can be productive in new languages immediately although it takes a long time to develop general and domain specific software engineering skills.

A friend of mine was in the same case when we were in the year 2 in college, he said I can’t do coding, and I can’t think in code, I don’t know what to write. Now he is working at Google :) so don’t lose hope.

What did he do ?

He dropped a year, and spent this year with the ACM chapter in college. The ACM creates a competition for college students, it’s called acm ICPC, through practicing for the acm competitions, you learn how to write a good code, and this is a sport called competitive programming, check this: Getting Started with the Sport of Programming
After this he did some good side projects while studying college materials, and got an internship, then he got a job in his local country, and finally after graduation by 2 years he could go to work for Google.

This is not the end of the world for you, my advice is:

1. Do competitive programming.
2. Revise the materials you studied in school or college.
3. Try to go with masters or PhD.
4. While doing the above 3 points, work on side projects, go with them from simple to hard, do a simple console game, then go bigger, start small without being shy, only if you want to be a real programmer.
5. Try to get an internship or any work even if you worked for free (It’s not a shame, I worked for free for 3 months for a company because they thought I was not good enough yet while I was in school) (I mean a company in computer science and your major for sure).

Edit1:

I want to edit 2 points, because of comments I received:

1. Having master degree or PhD degree in computer science may not make you a super programmer, as most of materials you will go with in these high degrees are theoretical, but on the other side, this will add a value to your CV, give you some facilities according to working as a R&D developer. also the theory itself if you combined it with coding, this will make you a better programmer with higher knowledge.
2. The person I talked about who took a gap year to make a good achievements, had a very close coach in his school, a coach who guided him to be good in competitive programming, so don’t think that it’s so easy to be a very good competitive programmer, it’s not easy, specially if you don’t have a good coach, but on yourself you can achieve a good state in competitive programming, maybe you will need more time, maybe if you are smart enough then you will do better than my friend in less time, nobody can really say for sure.

Edit2:

I just want to add YP Wong ‘s comment here, he said:

I have a Ph.D in computer science. I learned programming pretty much on my own before university on Apple II machine.The reality is, if you want to be really good at very specific field such as machine learning, master or Ph.D would definitely be good thing.But if you want to be a really good programmer, say in web or mobile development, you would do much better by just doing it everyday instead of spending your time in master or Ph.D research. Dong serious research means you really won’t get much time to do serious programming & development.

This maybe useful.

This depends a great deal on what kind of software you want to be working on, as the languages you've listed (Go, Scala, Erlang, Python) are all useful for different kinds of applications.

I've seen Python jobs pay very well, I've seen Scala jobs that pay very well, I've seen Go jobs that pay very well. I don't have any experience using our hiring for Erlang.

At the end of it all, if your “passion” for writing software is just the paycheck your going to get, this will be pretty easy to detect by interviewers. Personally, I prefer to hire people who are very passionate about the kinds of problems my company is trying to solve, not people who are in it for the money, or more interested in the tech we're using than what we're doing with the tech.

I'm not saying the salary is not important, it certainly is, but choosing an education path simply based on potential payout may not be your best use of time.

Plus, tech stacks change all the time, and being able to transfer your skills to another technology will be extremely valuable to a company. You might find a great job using Erlang only to have the company switch to something else completely a year later. Will you leave that job because your passion is more tied to tech stack than the company mission? Loyalty to employers means a lot in our industry, and leaving a job with a reason of “because I wanted to be working on ___ as my tech stack” is a pretty petty reason to leave a company.

In fields such as data science, Python can be used only for some parts of the stack. For all Python's ease of access to C libraries etc, it's a single threaded language that doesn't scale the way Scala can. Scala doesn't have the rapid prototyping ease of Python (although it's much closer to that than Java) but it can be used as a full stack language in those spaces.

Since you mentioned Spark, a very practical gain is being able to debug and patch/support the framework.

Other benefits might better be sought in general “Why should I learn Scala?” questions but here are 2:

In my experience, Scala is much more accessible to dynamic-language Devs than other statically typed languages. In two places I worked, the Perl devs took more quickly to Scala than the Java devs.

If you have any interest in functional programming, Scala is much more capable and expressive in that.

Aspiring Python developers often face the dilemma of selecting the right institute to learn Python programming and increase their employability. Here's a comprehensive guide to help you navigate this decision-making process and why Uncodemy emerges as a top choice:

1. Factors to Consider When Choosing an Institute:

When selecting an institute to learn Python and enhance your job prospects, consider the following factors:

• Course Curriculum: Look for institutes that offer comprehensive Python courses covering core concepts, libraries, frameworks, and practical applications relevant to your career goals.
• Faculty Expertise: Ensure that the institute has experienced instructors who are proficient in Python programming and possess industry experience. Quality teaching can significantly impact your learning experience.
• Hands-on Experience: Seek institutes that provide hands-on learning opportunities, such as coding exercises, projects, and real-world applications. Practical experience is crucial for mastering Python skills and building a strong portfolio.
• Industry Recognition: Choose institutes with a good reputation and industry recognition. Look for reviews, testimonials, and success stories from past students to gauge the institute's credibility and track record of placement assistance.
• Flexibility and Convenience: Consider factors such as course duration, class timings, online/offline options, and flexibility to accommodate your schedule and learning preferences.
• Cost and Value: Evaluate the cost of the course relative to the quality of education and value it offers. Look for institutes that provide a good return on investment in terms of learning outcomes and job opportunities.

2. Why Choose Uncodemy:

Uncodemy stands out as a premier choice for learning Python and preparing for a successful career in the tech industry. Here's why:

• Comprehensive Curriculum: Uncodemy offers a comprehensive Python course covering fundamental concepts, advanced topics, and practical applications. The curriculum is regularly updated to align with industry trends and demands.
• Experienced Instructors: Uncodemy boasts a team of experienced instructors who are experts in Python programming and have extensive industry experience. They provide personalized guidance, mentorship, and support to help students succeed.
• Hands-on Learning: Uncodemy emphasizes hands-on learning with coding exercises, projects, and real-world applications. Students gain practical experience and develop the skills necessary to tackle complex Python projects confidently.
• Industry Connections: Uncodemy has strong connections with leading companies and tech recruiters, facilitating networking opportunities, internships, and job placements for students. The institute's alumni have secured rewarding positions in top organizations across various industries.
• Flexible Learning Options: Uncodemy offers flexible learning options, including online courses, live classes, self-paced learning, and personalized coaching. Students can choose the format that best suits their schedule and learning preferences.
• Affordable Pricing: Despite offering high-quality education and valuable resources, Uncodemy maintains affordable pricing plans, making it accessible to students from diverse backgrounds.

In conclusion, choosing the right institute is crucial for learning Python effectively and securing a job in the tech industry. Consider factors such as course curriculum, faculty expertise, hands-on experience, industry recognition, flexibility, cost, and value when making your decision. With its comprehensive curriculum, experienced instructors, hands-on learning approach, industry connections, flexible options, and affordable pricing, Uncodemy emerges as an excellent choice for aspiring Python developers looking to kickstart their careers.

Actually now (2023) I can not see any connection between the languages used and getting the job.

What we see is the abundance of people and the lack of ideas how to make them produce something.

There’s a whole industry (HR) that exists mostly in the purpose of its existence. This is the first layer that separates you from the job you’re prepared to do.

Think about all those millions of people who have their job deciding if you’re qualified to do your job without understanding what your job looks like?

They all have to keep their job secure and there’re multiplies of them. So…. When faced on the task: “find me a good programmer, I don’t have time for this, we don’t have time for this, we need more people here” what will them all do?

They will ask: “what this person should look like?”. The answer: “ok, we work with the technology X and Y. Will be cool to see something who could help”.

So now we have “intern, junior, middle, senior..”. How? Just put it to simple numbers: “1 yr of experience, 3 yrs of experience, 7 yrs of experience(!!!????)”

Why? because you have to have something to measure. Check all this marks, and probably you will have a chance to be considered.

Having the whole HR industry you have to adapt to them. You have to study their habits and what will get you pass their layer to the first technical interview. And you will compete with millions of people in studying HR behaviour.

HR layer is what separates you from the technical interview.

So now we have a multi-million-people industry with its own rules existing only in the purpose of its own existing. Add courses and coaches and blog posts and people ready to polish your resume.

So you are asking the wrong question. Study what HR interview questions look like. Be in their “target group” including age, citizenship, good abilities in writing resume, behave according to their patterns etc etc….

Or.

Learn the programming languages. You, as a programmer, should do it anyway. Build your network of colleagues. Read a lot. Program a lot for fun. Hope that in your network somebody need someone to help with the tasks at hand.

Because the Scala jobs pay a lot more? That’s one serious motivation, if you’re good enough to make the grade.

Over the years, I have learned several languages that I don’t use at work. Each of them taught me something new and enabled me to look at the languages I do use with fresh eyes. The new knowledge helped me be a better programmer. One day I may find myself using them for things other than side projects, but even if that never happens, I will have gained something.

Scala has things to teach you that Python cannot. And vice versa. Knowing both would make you a more informed programmer than knowing only one. Python has some functional abstractions (if expressions, comprehensions, generators) but Scala has a much more powerful and comprehensive set of functional programming features. Scala can certainly teach you things that you can use to your profit in Python.

That said, if Python is likely to be your main work language, you might well do better to learn Haskell on the side. Haskell is often more accessible to Python programmers and is a purist FP language (Scala is hybrid FP and OO), so the FP lessons are clearer.

I continue to be puzzled (and disappointed) by people saying “Why should I learn X” or thinking they only need to know one language. Monolingual developers are not the best developers. They often struggle to see the difference between a computing concept and the way their language of choice happens to implement it. Having to relearn how to do things in a new language teaches you what is truly essential to the problem and what is trivial complication imposed by one language design.

Just learning Python, or any other scripting language for that matter won't give you a job.

If you understand the fundamental concepts of programming i.e loops, conditionals etc., learning a new language is just a matter of going through the documentation of that language. Cramming syntax isn't a very impressive skill to have, one can always Google that. What impresses people are your problem solving skills.

Lets say you know Python, and you apply for a job at a company working in the field of data analysis. Your application would be judged mainly on the basis of your knowledge of Probability and statistics, and other related fields.

Programming languages are just tools to solve complex problems.
Just having tools doesn't make a good craftsman.

Below are Python Job Profiles

• Software Engineer
• Research Analyst
• Data Analyst
• Data Scientist
• Software Developer

If you want to know about job openings then head over here : Welcome to Python.org

Keep following, i will add edits if i find something useful.

Thanks!

I find this question oddly hard to answer. Scala is a big language and I guess it's not a huge surprise that it has a few camps. I think it can be grouped by libraries and frameworks.

1. Scalaz/ purely functional: Some places are really trying to seriously use scala as a pure FP language. The scalaz library has its own versions of the more mainstream libraries for concurrency and other things. Places like this are probably looking for an ability to think functionally and some pure FP experience. They would probably be more interested in your conceptualization of FP than expectant of a lot of hands on experience with their specific stack.
2. Akka: if they are doing a lot of stuff with akka, which is a large possibility then its likely they would want you to know it. actor model, futures, etc ..
3. Scala noobs: this is not meant to be a put down. There are a lot of start-ups founded by very strong engineers who have decided to take the scala route for one reason or another and are learning it as they go. It could have something to do with Spark or some other framework they want to have access to, it could be they just like the language. In a lot of these cases you will find the engineers growing into the language, from initially writing in a style that more resembles their previous experience. A lot of times its that they are moving from Java, which can have the (unfortunate) effect of there being a big base of code that is essentially java written with the Scala syntax. Other times they are coming from python or even javascript. In these cases it will probably be mainly important to demonstrate a high degree of interest/familiarity with the basic language. Know your for comprehensions! They have put a lot of work into learning this Scala monster and will know some tricky questions around the languages eccentric issues they have uncovered along the way.

Generally think of it as any other interview except when you get to the white board your gonna code with Scala. And i wouldnt recommend being in a situation when they ask you to get up there and show them some scala and the first thing you do is break out a var and a while loop. If you can not get through a small technical challenge using pure FP then no one is going to take you seriously and they will think you are just faking the interest in scala to get an interview.

You have to think functional programming. But you're looking for specifics...

1. Understand how to transform iterative processes into (tail) recursive processes;
2. Understand how to design objects with mutable state into either immutable objects or actors;
3. Understand for comprehensions;
4. Know how to avoid nulls and exceptions by using Option and Future/Try (or Either if that floats your boat);
5. Understand how to compose functions, for example using a lift to transform a T=>R into a F[T]=>F[R] where F represents Option, Try, Future, etc.

Of course, you could always simply write Java code in Scala syntax and that would probably get you through some jobs--but it wouldn't make you sought after.

[EDIT] Since writing this answer, I've posted a new blog entry which addresses the first topic listed above.

The answers to these sorts of questions will be skewered. The reason is that the languages someone knows correlate with their skill level, even though this needn’t be the case inherently.

For example, a lot of beginners learn Python. So there will be a lot of beginner Python programmers. Meanwhile, Scala is rarely taught as a first language — and would be a horrible choice for this purpose, and is often picked up by programmers with at least some and often quite a lot of experience under the belt.

The Python beginners will drag the average figures down, while in Scala this won’t be the case. Therefore it may seem as if Scala programmers earn inherently more, but this is much more likely a reflection of their skill level or years of experience. A Python programmer with the same skill level and same years of experience would likely earn just as much.

Certain languages are also more popular in certain domains. For example, Haskell tends to be popular in the high-paying financial world. Once again, it is not the language but rather the domain and requisite skill set that determines how much you’d earn.

If you want the highest paid jobs, you shouldn’t focus too much on languages. You should focus on being a valuable software engineer.

Don’t waste time by taking notes.

Never go to anyone pay them for a computer language and take notes. It is important that you practice more.

I suggest that for basics you can take class in coursera.

For job level proficiency you’ll need lot more practice and understanding many modules and packages.

To gain more practice i suggest you take up Codeforces which is a Russian based coding arena for everyone. They have rounds every week gain at least a master level. Also try codechef and hackerrank.

Finally python for job would depend on the post.

1. For Data Sci : Numpy Scikit etc.
2. For ML: Numpy Scikit keras pandas.

i am sure of these.

Lisp is not a functional language. Though, it can be used that way, and I’ve often liked using it that way.

A few fun things I’ve done with it:

• Writing a “word to number” translator that converts words like “thirteen” and “thirty” to numbers.
• Writing an augmented transition network interpreter, in exercises from Chapter 19 of the book “Lisp” by Winston, Klaus, and Horn. (The ATNs I used parsed lists of atoms, representing simple sentences, into categories.)

I wrote about the the ATN interpreter at:

• Writing a crude object system

I wrote this object system in answer to a question about properties in Lisp:

A Lisp dialect that is functional is Scheme.

I had some “hard fun” with it in Section 3.5 of the book “Structure and Interpretation of Computer Programs” (often referred to as “SICP”), where it talked about using streams for expressing mathematical series.

Yes. Both languages are better than Java for developing on the JVM. Given the “or” in your question I would (and have) picked Clojure over Scala. Looking at the 2, Scala is the comparatively complex and trying to please everyone one every front language. Languages like that can get overly complex and become hard for the human to work with, fully utilize or even follow other’s code.

On the other hand Clojure is a straightforward language that started out small and simple. It has taken a single approach with some pragmatic decisions on working with various problems (No TCO in the JVM, fine the language adds something to figure it out). Some of the more recent additions to the language have made it more complex, but the reasons for going down that path are decent ones and probably well worth the expense.

While both languages support the functional programming style, Clojure being pure provides a way for a developer to be more productive and have a different way to think about problems. The increased cost in memory and CPU time are minimal in most cases. The cases where that trade off is not worthwhile, Scala isn’t your best choice either.

As for Erlang, it has slowly gained recognition since it was released as Open Source in 1998, already then being used commercially in so-called “five-nines”[1] telecoms systems. Perhaps a bit unusually for a telecoms technology, Erlang also became popular for the ease and elegance with with even very small teams could build robust messaging systems.

The emergence of “conversational web services” and web-scale databases meant that the kind of programming Erlang was designed for had entered the mainstream. Also, the shift towards multicore architectures put a spotlight on concurrency programming - something that Erlang excels at.

A few significant events caused at least temporary peaks in interest, for example:

• British Telecom wrote in a press release about an Erlang-based product achieving “nine nines” availability during an extended field trial. This became something of a meme for Erlang, as if Erlang guarantees “nine nines” by design. It was also the only publicly available in-service performance figure at the time, since Ericsson doesn’t reveal such data.
• It was rumored, and later confirmed, that Amazon SimpleDB was written in Erlang.
• It was revealed that Facebook Chat was implemented in Erlang, by a team of two programmers.
• The unusual database CouchDB, written in Erlang by Damien Katz, became popular.
• When Facebook acquired WhatsApp, it became known that they used Erlang as their secret sauce.

[1] 99.999% service availability, or ca 6 minutes downtime/year, including maintenance and upgrades.

A good question!

The increase in popularity is largely due to the following:

1. Parallel architectures: those enforced software to use different computational models that are easily used in parallel, all of this is to harness the true power of the multi-core processors we have in face of problems like big data.
2. Correctness: reasoning and proving a functional or logic program to be correct is both easier and more formalised than most approches in the procedural way.
3. Performance: I remember reading that Scala beats C++ in terms of generatrd lines of assembly code, this is due to the assumptions the compiler can make once we are in the functional realm of computation.
4. Easier to reason about: evaluation of expressions is more natural to humans than simulating a Von Neumann computer in our heads, which makes thinking much easier, at least for me.
5. Elegance: most primitive problem and even fairly complex ones (like ones on project Euler) can be solved in an elegant one line of code, use this to impress your procedural friends :-) .
6. Typing systems (only for statically typed languages): this deals with the thing most people hate about Python, which is dynamic typing. Dynamic typing is cool as long as you're writing small programs, but when assembling blocks of software, it often turns to be a source of problems, statically typed languages make compiling a program that has a type error impossible, this eliminates some of the tests that are needed in other languages.

Hope this helps!

A2A

You should have at least three years of experience, or be able to demonstrate (through a portfolio of work) that you have a wide breadth of knowledge.

I got my first Python job because I had written a book series about Python. All the knowledge and experience I had was from hobby programming and just learning new things to put in each book edition, but it justified to the dept. head that I was worth taking on.

I got my second Python job for much the same reason. The interview was very basic, as having the book on my resume was pretty much what clinched the deal.

Obviously, I’m not telling you to write a book or three, but you should be able to do just about everything that an introduction to Python book talks about. While you can learn the basics of Python and write coherent programs in just a few months, you will always be learning new things about the language. So don’t worry that you don’t know everything, but you should at least be able to write moderate-sized console-based applications and talk intelligently about how to use Python.

At home! Pick a real actual project you can make. Something substantial with a real function. Design and implement it. Then, prepare to explain in detail who and why you designed it the way you did. If I was looking for someone on my team, I’d be delighted to see someone presenting something real and useful that was designed and implemented, and where you’d be able to give honest truthful answers to anything I throw at you.
So, what project could you create, you wonder… What type of business and what type of projects would you enjoy working on for a living? Games? Database server side stuff? Web server with dynamic data driven content? Scientific processes? Construction? Logistics? Traffic control? Photography? Multimedia? So many choices !

The short answer is: it depends.

Clojure is certainly a simpler language than Scala. It has much less syntax, it has a much simpler type system, the core language is very small. It has a handful of core abstractions that permeate everything in the language (sequences primarily).

But Clojure is not like any of those other languages you've used before -- it's a Lisp -- and that means it's going to seem much more alien to you than Scala (which is, in some ways, a more cryptic version of Java). For some people, that alien appearance and "OMG! The Parentheses!" can be enough to make learning Clojure very difficult for some people.

I used Scala in production for a year or two and it's an impressive language but it certainly has its quirks (implicits can make code easier to read but much harder to really understand, for example). To truly get the benefits of what Scala offers, you need to embrace FP and you need to embrace its type system -- using it as just "a better Java" is a waste of a good language.

In 2011, I switched to Clojure and as of last year that officially became our primary language at work. I love Clojure: it maintains its simplicity even at scale, it's fluid and consistent, and the immediate feedback of a live REPL is amazing when developing applications.

I work with a team of developers who've mostly used dynamic scripting languages. I would say they found Clojure easier to learn than Scala overall -- but they struggled with the FP concepts in both and with Scala they also struggled with the type system as well.

Given your trajectory through a number of languages -- and the observation that a number of Rubyists have moved to Clojure and profess to love it -- I would say you'd find Clojure more satisfying, once you get over the shock of the syntax :)