The innovators in technology have long paved the way for greater social advancement. No one can dispute the fact that the impact of Bill Gates and Microsoft will be far reaching for many years to come. The question is whether or not Microsoft will be able to adapt and thrive in emerging markets. The fact that Microsoft enjoys four decades of establishment also makes it difficult to make major changes without alienating the 1.5 billion Windows users.

This was apparent with the release of Windows 8. Windows users had come to expect a certain amount of consistency from their applications. The Metro tile, touch screen interface left a lot to be desired for enough people that Microsoft eventually more thoroughly implemented an older desktop view minus a traditional Start menu.

The app focused Windows 8 was supposed to be a step towards a greater integration of Cloud technology. In recent years, Microsoft lagged behind its competitors in getting established in new technologies. That includes the billions of dollars the emerging mobile market offered and Cloud computing.

Amazon was the first powerhouse to really establish themselves in the Cloud technology market. Google, Microsoft, and smaller parties are all playing catch up to take a piece of the Cloud pie. More and more businesses are embracing Cloud technology as a way to minimize their equipment and software expenses. While it does take a bit for older businesses to get onboard with such a change, start ups are looking at Cloud computing as an essential part of their business.

But what does that mean for Microsoft? Decisions were made to help update the four decade old Microsoft to the "always on" world we currently live in. Instead of operating in project "silos", different departments were brought together under more generalized headings where they could work closer with one another. Electronic delivery of software, including through Cloud tech, puts Microsoft in the position of needing to meet a pace that is very different from Gates’ early days.

The seriousness of their desire to compete with the likes of Amazon is their pricing matching on Cloud infrastructure services. Microsoft is not a company that has traditionally offered price cuts to compete with others. The fact that they have greatly reduced rates on getting infrastructure set up paves the way for more business users of their Cloud-based apps like Microsoft Office. Inexpensive solutions and free applications open the doors for Microsoft to initiate more sales of other products to their clients.

Former CEO Steve Ballmer recognized there was a need for Microsoft to change directions to remain competitive. In February 2014, he stepped down as CEO stating that the CEO needed to be there through all stages of Microsoft's transition in these more competitive markets. And the former role of his chosen successor, Mr. Satya Nadella? Head of Microsoft's Cloud services division.

Microsoft may not always catch the initial burst of a new development in their space; but they regularly adapt and drive forward. The leadership of Microsoft is clearly thinking forward in what they want to accomplish as sales of PCs have stayed on a continuous decline. It should come as no surprise that Microsoft will embrace this new direction and push towards a greater market share against the likes of Amazon and Google.

Related:

Who Are the Main Players in Big Data?

Is Cloud Computing Safe for Your Business?

Is The Grass Greener in Mobile App Development?

The name placard in your cube might not say anything about sales, but the truth is that everyone, employed as such or not, is a salesperson at some point every single day. In the traditional sense, this could mean something like pitching your company’s solutions to a client. In the less-traditional sense, it could mean convincing your child to eat their vegetables. Yet for those two drastically different examples and everything in between, there is a constant for successful sellers: unveiling the “Why.”

Spending time and energy making prospects understand why you do what you do instead of exactly what it is you do or how you do it is not a new concept. But I’m a firm believer that proven concepts, no matter how old and frequently referenced they are, can’t be repeated enough. This idea has recently and fervently been popularized by marketer, author, and thinker extraordinaire Simon Sinek via his 2009 book, Start With Why. You can learn about him here on Wikipedia or here on his site. To begin, let me suggest that you watch Sinek’s TED talk on Starting With Why here on YouTube before reading any further. I’ll let him take care of the bulk of explaining the basics, and then will offer some ideas of my own to back this up in the real world and explore the best ways to start thinking this way and apply it to your business.

First, a little on me. After all, if I were to practice what Sinek preaches, it would follow that I explain why it is I’m writing this piece so that you, the reader, not only have a good reason to pay attention but also understand what drives me on a deeper level. So, who am I? I’m an entrepreneur in the music space. I do freelance work in the realms of copywriting, business development, and marketing for artists and industry / music-tech folks, but my main project is doing all of the above for a project I’ve been on the team for since day one called Presskit.to. In short, Presskit.to builds digital portfolios that artists of all kinds can use to represent themselves professionally when pitching their projects to gatekeepers like label reps, casting directors, managers, the press, etc. This core technology is also applicable to larger entertainment industry businesses and fine arts education institutions in enterprise formats, and solves a variety of the problems they’re facing.

Not interesting? I don’t blame you for thinking so, if you did. That’s because I just gave you a bland overview of what we do, instead of why we do it. What if, instead, I told you that myself and everyone I work with is an artist of some sort and believes that the most important thing you can do in life is create; that our technology exists to make creators’ careers more easily sustainable. Or, another approach, that we think the world is a better place when artists can make more art, and that because our technology was built to help artists win more business, we’re trying our best to do our part. Only you can be the judge, but I think that sort of pitch is more compelling. It touches on the emotions responsible for decision making that Sinek outlines in his Ted Talk, rather than the practical language-based reasons like pricing, technicalities, how everything works to accomplish given goals, etc. These things are on the outside of the golden circle Sinek shows us for a reason – they only really matter if you’ve aligned your beliefs with a client’s first. Otherwise these kind of tidbits are gobbledygook, and mind-numbingly boring gobbledygook at that.

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.