And each new version the adherence to the standards grew considerably. The real problem was that IE6 was the top dog for so freaking long that every single site on the web was made to support it. IE7 and 8 are still a clusterfuck to develop for, but IE9 is ok. It is missing a lots of modern features but the ones it does have it adheres to the standard quite well (its debugger still sucks though, so it is still annoying to develop for it). I develop targeting IE>=9, Chrome, Firefox and Safari and I don't have more problems with IE than I have with any other browsers.
Slashdot videos: Now with more Slashdot!
Developers! Developers! Developers!
They always tried to make platforms that were easy to program for, it is just that the platform changed. Yes, they were dragged to this new platform kicking and screaming, but it was inevitable.
Also a monoculture based on an open source project is very different than what we had before.
You can make shadows gradients and most visual effects in vector graphics, I can not think anything a icon might try to do that could not be done easily in vector graphics.
Disclaimer: I am not a graphics artist expert, if someone could point something that can not be done well in vector graphics I would like to know.
I do agree they are butt ugly, but honestly I haven't never cared much about these things, heck in windows 7 I used to use the classic shell look, when I changed to 8 they dropped that option and I did not really care that much. What really pisses though is those damn fat window borders, I actually looked up the register keys to change them and I use my windows machine pretty much only for gaming and occasional browsing. I think they are that way because of touch screen support. In my opinion windows XP had the best icons, but I have better things to worry about than arguing icons on slashdot (or apparently I do not, it has been a slow day so far).
And I vowed to never again buy a paper book that is available in electronic format in my life. There are no distractions in the kindle and I can have all the books I want at any time and, you know, not cut down a tree in the process. But really I believe it is a better experience, books are heavy and I get enough wrist strain from using my computer, I can leave markers and it is easier to use the index for text-books. Sure the amazon DRM is not very cool but the convenience makes up for it.
In my opinion they should be giving kids kindles and not ipads in schools. When I was a child I was hungry to find good books but I could never find or afford to buy them.
Tomcat, Glassfish, IBM WebSphere, BEA/Oracle Weblogic, Jetty, JBoss those are the ones I can name right now, but surely there are more, each one with their own bugs and unique features that makes porting an application from one to the other a nightmare.
Seriously you can make a whole career path being an "Certified WebSphere Application Server Developer", that is how complex each application server can be.
The right term is "scales horizontally easily", but the parent post had the right idea. You can run multiple node processes in the same machine to use their multicore processors in order to handle more requests as well as run node processes across a huge cluster of machines. The event-driven architecture makes you design your application in a stateless manner so scaling it across multiple processes/processor-cores/machines is easy.
By stateless manner I mean that your application stores any state data in a database that can also "easily scale horizontally" like mongo. Your traditional Java application stores a ton of state (just check Apache Tomcat session replication for an example), sure it is much faster in a single node, but once you need to synchronize all that data across multiple nodes not only your performance degrades, but your developers start to go crazy trying to get all the frameworks and their own code to play nice.
You can design stateless Java applications, but it is not very common in my experience, Java frameworks usually go the route of trading information between nodes which makes horizontal scaling hard and reliability down (it is hard to eliminate all of the single point of failures).
I think the main advantage of node vs java is that the single threading model is MUCH more simple, anyone who ever wrote a considerable size Java application knows that threads always bite you in the ass. This makes developers life easier, but you need to architecture your application in a different way. If performance is not critical you can get away with this, if performance is critical node can scale horizontally very well. Horizontal-scaling a single server Java application usually requires redesigning the whole thing, while node applications due to the single-thread mechanics incentive you to write stateless code that makes scaling horizontally a matter of plugging more servers and adding a load balancer (which you also have to do in Java).
In short if you have your application completely specified from the start and knows it will never ever change its specification Java would probably be a better choice, type safety really is useful for megaton projects with lots of little parts that have fixed requirements and you can design the threading model from the start to satisfy your requirements. If you are writing an application that evolves constantly node is a better option because it can adapt itself more easily to changing requirements, untyped languages are very good for this.
This protocol will enable new types of web applications, things like realtime multiplayer games that need to constantly stream lots of packets at a lower latency. Things that are not done today because the current technology simply can not provide a good enough experience. Plus it will reduce your server load which is nice (marketing scripts and ads are served from third party servers).
The problem is that globalization means that EVERYONE collapses at the SAME time, all those old civilizations collapsed over an extended period of time and most parts of the world were not affected directly by their downfall. I don't think our retrospective lessons of past events will help much for the future in this case.
I had a dell XPS15 model with a manufacturing defect that made the computer crash when running games, the only way to solve it was to underclock the GPU. No it was not overheating, it was a manufacturing problem, there are several accounts of this problem on the net.
My fellow co-works give me flak for writing like this:
foobar= foo + bar
While they write like this:
foobar = foo + bar
Personally when reading other peoples code I don't mind either, I don't go around their code removing the spaces, but I am so used to writing without the space before the equal sign that even if I am trying to write code in their standard I sometimes forget. They say they can see which parts of the code was written by me just because of that little quirk. That quirk would not be lost in Python, but granted, it removes the other developer quirk:
We considered implementing syntax coding standards, but honestly I do not think they help all that much so we never ended up using any. And really, individual coding styles are sometimes useful, if I see a code with the curly braces in the following line and I have a problem with that code I know exactly who to talk to without needing to check git.
I first learned to program in Pascal, in which that statement would be like this:
foobar:= foo + bar
Since pascal has two characters for the attribution operation it looks odd with the space before it.
It was not so much a case of micro-management and more a case of "either way is fine by me", if I had insisted on keeping 3 numbers they would let me. We only realized the problems of saying 4 numbers out loud after a while when it was too late to change it.
As matter of fact bug-fixes that don't break backwards compatibilities usually have their own separate number (the last number in the number version):
MAJOR_VERSION . MINOR_VERSION . BUG_FIXES
So you can update your software safely if you keep the same major and minor versions.
In my project the upper echelon of the company wanted to stress out that this was version two of our product (even though the "second version" does not share any code at all with the first) so we ended up introducing one more number to our version semantics:
MARKETING_VERSION . MAJOR_VERSION . MINOR_VERSION . BUG_FIXES
And this marketing version is 2 and will likely never change. I told them they could keep calling it whatever they wanted in the marketing department since the user can only see the full number in the about screen but they insisted, now our team always gets confused when saying version numbers out loud (I remember fondly the time we hit 220.127.116.11).
No, what you end up having is Lisp.