Java still has its place in the world of software development, but is it quickly becoming obsolete by the more dynamically enabled Python programming language? The issue is hotly contested by both sides of the debate. Java experts point out that Java is still being developed with more programmer friendly updates. Python users swear that Java can take up to ten times longer to develop. Managers that need to make the best decision for a company need concrete information so that an informed and rational decision can be made.

First, Java is a static typed language while Python is dynamically typed. Static typed languages require that each variable name must be tied to both a type and an object. Dynamically typed languages only require that a variable name only gets bound to an object. Immediately, this puts Python ahead of the game in terms of productivity since a static typed language requires several elements and can make errors in coding more likely.

Python uses a concise language while Java uses verbose language. Concise language, as the name suggests, gets straight to the point without extra words. Removing additional syntax can greatly reduce the amount of time required to program.  A simple call in Java, such as the ever notorious "Hello, World" requires three several lines of coding while Python requires a single sentence. Java requires the use of checked exceptions. If the exceptions are not caught or thrown out then the code fails to compile. In terms of language, Python certainly has surpassed Java in terms of brevity.

Additionally, while Java's string handling capabilities have improved they haven't yet matched the sophistication of Python's. Web applications rely upon fast load times and extraneous code can increase user wait time. Python optimizes code in ways that Java doesn't, and this can make Python a more efficient language. However, Java does run faster than Python and this can be a significant advantage for programmers using Java. When you factor in the need for a compiler for Java applications the speed factor cancels itself out leaving Python and Java at an impasse.

While a programmer will continue to argue for the language that makes it easiest based on the programmer's current level of knowledge, new software compiled with Python takes less time and provides a simplified coding language that reduces the chance for errors. When things go right, Java works well and there are no problems. However, when errors get introduced into the code, it can become extremely time consuming to locate and correct those errors. Python generally uses less code to begin with and makes it easier and more efficient to work with.

Ultimately, both languages have their own strengths and weaknesses. For creating simple applications, Python provides a simpler and more effective application. Larger applications can benefit from Java and the verbosity of the code actually makes it more compatible with future versions. Python code has been known to break with new releases. Ultimately, Python works best as a type of connecting language to conduct quick and dirty work that would be too intensive when using Java alone. In this sense, Java is a low-level implementation language. While both languages are continuing to develop, it's unlikely that one language will surpass the other for all programming needs in the near future.

As someone who works in many facets of the music industry, I used to seethe with a mixture of anger and jealousy when I would hear people in more “traditional” goods-based industries argue in favor of music content-based piracy. They made all the classic talking points, like “I wouldn’t spend money on this artist normally, and maybe if I like it I’ll spend money on them when they come to town” (which never happened), or “artists are rich and I’m poor, they don’t need my money” (rarely the case), or the worst, “if it were fairly priced and worth paying for, I’d buy it” (not true).  I always wondered if they’d have the same attitude if 63% of the things acquired by customers in their industries weren’t actually paid for, as was conservatively estimated as the case for the music industry in 2009 (other estimations put the figure of pirated music at 95%). Well, we may soon see the answer to curiosities like that. Though one can say with tentative confidence that music piracy is on the decline thanks to services like Spotify and Rdio, it could be looming on the horizon for the entire global, physical supply chain. Yes, I’m talking about 3d printers.

Before I get into the heart of this article, let me take a moment to make one thing clear: I think these machines are incredible. It’s damn near inspiring to think of even a few of their potentially world-changing applications: affordable, perfectly fit prosthetic limbs for wounded servicemen and women; the ability to create a piece of machinery on the spot instead of having to wait for a spare to arrive in the mail, or en route if your car or ship breaks down in a far away place; a company based out of Austin, TX even made a fully functioning firearm from a 3d printer a few months ago.

If these machines become as consumer-friendly and idiot-proof as possible (like computers), it’s possible that in a matter of decades (maybe less), a majority of U.S. households will have their own 3d printer. There’s also the possibility they could take the tech-hobbyist path, one that is much less appealing to the masses. Dale Dougherty of Makezine.com estimates there are currently around 100,000 “personal” 3d printers, or those not owned for business or educational purposes. I don’t think they’ll ever be as ubiquitous as computers, but there are plenty of mechanically inclined, crafty hobbyists out there who would love to play around with a 3d printer if it was affordable enough.

That being said, is there reason to worry about the economic implications of consumers making what they want, essentially for free, instead of paying someone else to produce it? Or will the printers instead be used for unique items more so than replicating and ripping off other companies’ merchandise in mass amounts? The number of people working in industries that would be affected by a development like this is far greater than the number of people who work in content-based industries, so any downturn would probably have a much larger economic implications. Certainly, those times are a ways off, but a little foresightedness never hurt anyone!

It is rather unfortunate that in the ever changing and rapidly improving world of technology, we hardly remember the geniuses who through their inventions laid the foundation for many of the conveniences and features we now enjoy in our favorite communication devices.

This article is a tribute to the ten people who made these discoveries and an attempt to bring their achievements into the limelight.

1.      Marty Cooper

Did you know that Cooper was the first to file the patent in 1973, when he was already working for Motorola for the “radio telephone system”. The Cooper’s Law is his brainchild and to think that he himself was inspired to come out with the patent was Star Trek and its Captain Kirk is indeed revealing.

2. Mike Lazardidis
 

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.