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.

Creating an enum in Python prior to Python 3.4 was accomplished as follows:

def enum(**enums)::
      return type('Enum',(),enums)

then use as:

Animals=enum(Dog=1,Cat=2)

and accessed as:

Animals.Dog

The new version can be created as follows:

from enum import Enum

class Animal(Enum):
    Dog=1
    Cat=2

What are some of the software development headaches associated with iPhone vs Android development?

The Boss (hereafter referred to as TB), handed me this research assignment. Hey, I finally got a little bit of one ups man ship on TB.

This is a significant moment in my life. Like me, TB isn't really human. I know because neither of us seem to indulge in that luxury known as sleep. That makes it extremely difficult to have any sort of 'gotcha'. I'm dancing. I got one.

In the warp speed development cycles we are now facing, TB must have gone to sleep, which in human terms is known as a wink. (About a 40th of the second).
18 June 2012 Monday, 3:30 PM (15:30 HRS) UTC -8, in Los Angeles Microsoft is making a major tablet announcement, revealing its own hardware that is tablet-based. Do not be surprised if it entails a Hollywood Inc. focus.

 Unlike traditional online courses that charge a fee, limit enrollment and provide credit or certification, Moocs (massive open online courses) are usually free or low cost and can host hundreds of  thousands global participants.  Although MOOC have been around for years in the form of collective techie learning gatherings, participation in 2012 has ballooned at a rapid pace likened to FaceBook in its heyday.  According to The Year of the MOOCarticle in the New YorkTimes, edX, a nonprofit start-up backed by Harvard and MIT, had 370,000 registrants in the fall of its first official courses. This paled in comparison to the amount of students that Courseraattained in its first year of online learning opportunities, 1.7 million!

Will MOOCs Replace education as we know it?

Like any new trend, massive participation in online classes has its challenges. Lynda Weinman has ample experience when pointing out that they are by no means a replacement for formal education.  As a former digital animator, special effects designer and classroom college teacher, Linda paved the path for an earlier version of MOOC education in the mid 90’s when she founded Lynda.comas an aide to her own students. Over four million students and 2,200 courses later she’s confident when clarifying that many of the collegespartnered with Lynda.com use the tutorials as added features to their existing courses.  When asked in an interview with ReadWriteBuilders, if high technical companies look at online programs in terms of advancement as a supplement to traditional education or as a way for people to further their careers, Lynda feels that “it’sjust one example of something that you can do to enhance your attractiveness to potential employers. But [it’s also important to have] a portfolio and body of work, references that actually work out, showing that you had success in the past.”

MOOC Benefits: