Facebook was originally intended as a way for people to stay in touch with friends and family members by sharing pictures and status updates on their timeline. As the website's popularity has grown, so has criticism that it is becoming one giant, online high school.

Online Bullying

There has been a dramatic increase in recent years in the number of online bullying cases due to the introduction of social media. Bullying isn't just limited to younger Facebook users, either. Many adult users have also resorted to bashing others online through nasty status updates and cruel comments.

Prior to social media, bullying in high school involved "kick me" signs and toilet swirling. Facebook and other social media outlets have allowed users to take bullying to a whole other level. Victims can no longer escape bullying by leaving school or work. The torture continues online, at anytime and anyplace.

Status "Likes"

In high school, everyone wants to be part of the popular crowd; people who are outgoing, beautiful, and seem like they have everything.  Posting a status update is similar to wanting to be popular. Once an update is posted, many users wait with bated breath to see how many friends will "like" their status. They believe that the more "likes" they receive, the more popular they are.

If that isn’t enough, there are many Facebook games that involve "liking" someone's status. Games like "Truth Is", where someone likes a status update and in return the poster writes how they really feel about the friend on their Facebook wall. This can get touchy, especially if the two people aren't friends outside of Facebook. It's similar to high school where someone desperately wants another person to like them, but when they find out how that person really feels they are crushed.

Relationships Are Difficult to Keep Private

When someone signs up for Facebook they’re asked to complete their profile, which includes a relationship section. Users can select from different options including "single", "married", "widowed", and "divorced". Whenever someone changes their relationship status, the update shows up on each of their friend's news feeds.

It's easy to see how this feature correlates with high school where everyone talks about who is dating who or which couple broke up. It used to be that after graduation, people were able to keep their relationships more to themselves. Not so anymore in the age of social media. Now everyone has the ability to state their opinion on a friend's relationship status, either by "liking" their status change or by commenting on it.

Facebook has presented many benefits to its users, including the ability to rekindle old high school friendships. What one must understand when they sign up for the service is that they are opening themselves up to the same criticism and drama that takes place in a high school setting.

Proceed with caution!

Being treated like a twelve year old at work by a Tasmanian-devil-manager and not sure what to do about it? It is simply a well-known fact that no one likes to be micro managed. Not only do they not like to be micro managed, but tend to quit for this very reason. Unfortunately the percentage of people leaving their jobs for this reason is higher that you would imagine. Recently, an employee retention report conducted by TINYpulse, an employee engagement firm, surveyed 400 full-time U.S. employees concluded that, "supervisors can make or break employee retention."

As companies mature, their ability to manage can be significant to their bottom line as employee morale, high staff turnover and the cost of training new employees can easily reduce productivity and consequently client satisfaction.  In many cases, there is a thin line between effective managing and micro managing practices. Most managers avoid micro managing their employees. However, a decent percentage of them have yet to find effective ways to get the most of their co-workers.  They trap themselves by disempowering people's ability to do their work when they hover over them and create an unpleasant working environment. This behavior may come in the form of incessant emailing, everything having to be done a certain way (their way), desk hovering, and a need to control every part of an enterprise, no matter how small.

Superimpose the micro manager into the popular practice of Agile-SCRUM methodology and you can imagine the creative ways they can monitor everything in a team, situation, or place. Although, not always a bad thing, excessive control, can lead to burnout of managers and teams alike.  As predicted, agile project management has become increasingly popular in the last couple of decades in project planning, particularly in software development.  Agile methodology when put into practice, especially in IT, can mean releasing faster functional software than with the traditional development methods. When done right, it enables users to get some of the business benefits of the new software faster as well as enabling the software team to get rapid feedback on the software's scope and direction.

Despite its advantages, most organizations have not been able to go “all agile” at once. Rather, some experiment with their own interpretation of agile when transitioning.  A purist approach for instance, can lead to an unnecessarily high agile project failure, especially for those that rely on tight controls, rigid structures and cost-benefit analysis.  As an example, a premature and rather rapid replacement of traditional development without fully understating the implications of the changeover process or job roles within the project results in failure for many organizations.  

For those newly moving into the realm of programming, the important question to mull over is what programming language or technology to specialize in. On the other hand, those who are already working as a software developer, the constant worry remains whether their current technology would become obsolete very soon.

Both these concerns could be easily addressed by checking the list of programming languages that are highly in demand and formulating the career by modifying your specialization accordingly. The supply for the developers have not met with the demand in these programming languages yet, making them most viable options for career.

Popular Programming Languages Based on TIOBE Index

The top 10 list of programming languages which are highly in demand in 2014 is listed below in the order of popularity. These languages are identified from the TIOBE Programming Community index which consists of 20 top programming languages. TIOBE index is an indicator of the popularity of programming languages and is updated once in every month.  This index is calculated using multiple search engines, and the ratings are based on the number of skilled engineers world-wide, courses and third party vendors.

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.