The original article was posted by Michael Veksler on Quora

A very well known fact is that code is written once, but it is read many times. This means that a good developer, in any language, writes understandable code. Writing understandable code is not always easy, and takes practice. The difficult part, is that you read what you have just written and it makes perfect sense to you, but a year later you curse the idiot who wrote that code, without realizing it was you.

The best way to learn how to write readable code, is to collaborate with others. Other people will spot badly written code, faster than the author. There are plenty of open source projects, which you can start working on and learn from more experienced programmers.

Readability is a tricky thing, and involves several aspects:

1. Never surprise the reader of your code, even if it will be you a year from now. For example, don’t call a function max() when sometimes it returns the minimum().
2. Be consistent, and use the same conventions throughout your code. Not only the same naming conventions, and the same indentation, but also the same semantics. If, for example, most of your functions return a negative value for failure and a positive for success, then avoid writing functions that return false on failure.
3. Write short functions, so that they fit your screen. I hate strict rules, since there are always exceptions, but from my experience you can almost always write functions short enough to fit your screen. Throughout my carrier I had only a few cases when writing short function was either impossible, or resulted in much worse code.
4. Use descriptive names, unless this is one of those standard names, such as i or it in a loop. Don’t make the name too long, on one hand, but don’t make it cryptic on the other.
5. Define function names by what they do, not by what they are used for or how they are implemented. If you name functions by what they do, then code will be much more readable, and much more reusable.
6. Avoid global state as much as you can. Global variables, and sometimes attributes in an object, are difficult to reason about. It is difficult to understand why such global state changes, when it does, and requires a lot of debugging.
7. As Donald Knuth wrote in one of his papers: “Early optimization is the root of all evil”. Meaning, write for readability first, optimize later.
8. The opposite of the previous rule: if you have an alternative which has similar readability, but lower complexity, use it. Also, if you have a polynomial alternative to your exponential algorithm (when N > 10), you should use that.

Use standard library whenever it makes your code shorter; don’t implement everything yourself. External libraries are more problematic, and are both good and bad. With external libraries, such as boost, you can save a lot of work. You should really learn boost, with the added benefit that the c++ standard gets more and more form boost. The negative with boost is that it changes over time, and code that works today may break tomorrow. Also, if you try to combine a third-party library, which uses a specific version of boost, it may break with your current version of boost. This does not happen often, but it may.

Don’t blindly use C++ standard library without understanding what it does - learn it. You look at std::vector::push_back() documentation at it tells you that its complexity is O(1), amortized. What does that mean? How does it work? What are benefits and what are the costs? Same with std::map, and with std::unordered_map. Knowing the difference between these two maps, you’d know when to use each one of them.

Never call new or delete directly, use std::make_unique and [cost c++]std::make_shared[/code] instead. Try to implement usique_ptr, shared_ptr, weak_ptr yourself, in order to understand what they actually do. People do dumb things with these types, since they don’t understand what these pointers are.

Every time you look at a new class or function, in boost or in std, ask yourself “why is it done this way and not another?”. It will help you understand trade-offs in software development, and will help you use the right tool for your job. Don’t be afraid to peek into the source of boost and the std, and try to understand how it works. It will not be easy, at first, but you will learn a lot.

Know what complexity is, and how to calculate it. Avoid exponential and cubic complexity, unless you know your N is very low, and will always stay low.

Learn data-structures and algorithms, and know them. Many people think that it is simply a wasted time, since all data-structures are implemented in standard libraries, but this is not as simple as that. By understanding data-structures, you’d find it easier to pick the right library. Also, believe it or now, after 25 years since I learned data-structures, I still use this knowledge. Half a year ago I had to implemented a hash table, since I needed fast serialization capability which the available libraries did not provide. Now I am writing some sort of interval-btree, since using std::map, for the same purpose, turned up to be very very slow, and the performance bottleneck of my code.

Notice that you can’t just find interval-btree on Wikipedia, or stack-overflow. The closest thing you can find is Interval tree, but it has some performance drawbacks. So how can you implement an interval-btree, unless you know what a btree is and what an interval-tree is? I strongly suggest, again, that you learn and remember data-structures.

These are the most important things, which will make you a better programmer. The other things will follow.

In the ever changing landscape of software programming, it is not surprising that developers and employees have a different set of preferences for desired skills.  However the number one language that developers want to learn according to a survey of developers by technical recruiter, Hacker Rank is Python. This is not a surprise considering that Python has been in demand for several years and programmers tend to really enjoy this language for clear syntax, good OOP support and great shortcuts. Python, named “the language of the year” in 2007 and 2010 in the TIOBE Index and has climbed to #4 status in May of 2018.

According to the study, employers want developers who:

-  Have problem-solving skills, such as the ability to break down large, complex problems.
- Are proficient in their programming language and debugging.
- Can design systems.
- Can optimize performance.
- Have experience in reviewing and testing code.
- Are proficient in database design

Surprisingly, formal education is not the deciding factor when it comes to what companies care about the most. People with computer degrees or certifications on a resume are not necessarily a first choice for hiring managers. Others that have years of experience even if those individuals are partially self-taught in the field stand to be taken seriously in the field.   For those individuals with a passion to learn and master a skill, there are ample opportunities with smaller to mid-sized companies.

Some interesting FAQ’s from the study:

    On average, developers know 4 languages, and they aspire to learn 4 more.
    Younger developers between 18 and 24 plan to learn 6 languages.
    Folks older than 35 only plan to learn and additional 3 languages.
    The top languages developers said they will learn were, Go, Python, Scala, Kotlin, and Ruby.
    There is a large gap between employers seeking developers that know React than there are folks that can do it.

So, Why Learn Python?
It is now the most popular introductory teaching language in U.S. universities.  Python is easy to use, powerful, and versatile, making it a great choice for beginners and experts alike. It allows you to think like a programmer and not waste time understanding difficult syntax that other programming languages can command. And, because of its rapid growth, many developers contribute to the Python community and share Python libraries making creativity that much more a reality

It is said that spoken languages shape thoughts by their inclusion and exclusion of concepts, and by structuring them in different ways. Similarly, programming languages shape solutions by making some tasks easier and others less aesthetic. Using F# instead of C# reshapes software projects in ways that prefer certain development styles and outcomes, changing what is possible and how it is achieved.

F# is a functional language from Microsoft's research division. While once relegated to the land of impractical academia, the principles espoused by functional programming are beginning to garner mainstream appeal.

As its name implies, functions are first-class citizens in functional programming. Blocks of code can be stored in variables, passed to other functions, and infinitely composed into higher-order functions, encouraging cleaner abstractions and easier testing. While it has long been possible to store and pass code, F#'s clean syntax for higher-order functions encourages them as a solution to any problem seeking an abstraction.

F# also encourages immutability. Instead of maintaining state in variables, functional programming with F# models programs as a series of functions converting inputs to outputs. While this introduces complications for those used to imperative styles, the benefits of immutability mesh well with many current developments best practices.

For instance, if functions are pure, handling only immutable data and exhibiting no side effects, then testing is vastly simplified. It is very easy to test that a specific block of code always returns the same value given the same inputs, and by modeling code as a series of immutable functions, it becomes possible to gain a deep and highly precise set of guarantees that software will behave exactly as written.

Further, if execution flow is exclusively a matter of routing function inputs to outputs, then concurrency is vastly simplified. By shifting away from mutable state to immutable functions, the need for locks and semaphores is vastly reduced if not entirely eliminated, and multi-processor development is almost effortless in many cases.

Type inference is another powerful feature of many functional languages. It is often unnecessary to specify argument and return types, since any modern compiler can infer them automatically. F# brings this feature to most areas of the language, making F# feel less like a statically-typed language and more like Ruby or Python. F# also eliminates noise like braces, explicit returns, and other bits of ceremony that make languages feel cumbersome.

Functional programming with F# makes it possible to write concise, easily testable code that is simpler to parallelize and reason about. However, strict functional styles often require imperative developers to learn new ways of thinking that are not as intuitive. Fortunately, F# makes it possible to incrementally change habits over time. Thanks to its hybrid object-oriented and functional nature, and its clean interoperability with the .net platform, F# developers can gradually shift to a more functional mindset while still using the algorithms and libraries with which they are most familiar.

Related F# Resources:

F# Programming Essentials Training

Machine learning systems are equipped with artificial intelligence engines that provide these systems with the capability of learning by themselves without having to write programs to do so. They adjust and change programs as a result of being exposed to big data sets. The process of doing so is similar to the data mining concept where the data set is searched for patterns. The difference is in how those patterns are used. Data mining's purpose is to enhance human comprehension and understanding. Machine learning's algorithms purpose is to adjust some program's action without human supervision, learning from past searches and also continuously forward as it's exposed to new data.

The News Feed service in Facebook is an example, automatically personalizing a user's feed from his interaction with his or her friend's posts. The "machine" uses statistical and predictive analysis that identify interaction patterns (skipped, like, read, comment) and uses the results to adjust the News Feed output continuously without human intervention. 

Impact on Existing and Emerging Markets

The NBA is using machine analytics created by a California-based startup to create predictive models that allow coaches to better discern a player's ability. Fed with many seasons of data, the machine can make predictions of a player's abilities. Players can have good days and bad days, get sick or lose motivation, but over time a good player will be good and a bad player can be spotted. By examining big data sets of individual performance over many seasons, the machine develops predictive models that feed into the coach’s decision-making process when faced with certain teams or particular situations. 

General Electric, who has been around for 119 years is spending millions of dollars in artificial intelligence learning systems. Its many years of data from oil exploration and jet engine research is being fed to an IBM-developed system to reduce maintenance costs, optimize performance and anticipate breakdowns.

Over a dozen banks in Europe replaced their human-based statistical modeling processes with machines. The new engines create recommendations for low-profit customers such as retail clients, small and medium-sized companies. The lower-cost, faster results approach allows the bank to create micro-target models for forecasting service cancellations and loan defaults and then how to act under those potential situations. As a result of these new models and inputs into decision making some banks have experienced new product sales increases of 10 percent, lower capital expenses and increased collections by 20 percent. 

Emerging markets and industries

By now we have seen how cell phones and emerging and developing economies go together. This relationship has generated big data sets that hold information about behaviors and mobility patterns. Machine learning examines and analyzes the data to extract information in usage patterns for these new and little understood emergent economies. Both private and public policymakers can use this information to assess technology-based programs proposed by public officials and technology companies can use it to focus on developing personalized services and investment decisions.

Machine learning service providers targeting emerging economies in this example focus on evaluating demographic and socio-economic indicators and its impact on the way people use mobile technologies. The socioeconomic status of an individual or a population can be used to understand its access and expectations on education, housing, health and vital utilities such as water and electricity. Predictive models can then be created around customer's purchasing power and marketing campaigns created to offer new products. Instead of relying exclusively on phone interviews, focus groups or other kinds of person-to-person interactions, auto-learning algorithms can also be applied to the huge amounts of data collected by other entities such as Google and Facebook.

A warning

Traditional industries trying to profit from emerging markets will see a slowdown unless they adapt to new competitive forces unleashed in part by new technologies such as artificial intelligence that offer unprecedented capabilities at a lower entry and support cost than before. But small high-tech based companies are introducing new flexible, adaptable business models more suitable to new high-risk markets. Digital platforms rely on algorithms to host at a low cost and with quality services thousands of small and mid-size enterprises in countries such as China, India, Central America and Asia. These collaborations based on new technologies and tools gives the emerging market enterprises the reach and resources needed to challenge traditional business model companies.