Python and Ruby, each with roots going back into the 1990s, are two of the most popular interpreted programming languages today. Ruby is most widely known as the language in which the ubiquitous Ruby on Rails web application framework is written, but it also has legions of fans that use it for things that have nothing to do with the web. Python is a big hit in the numerical and scientific computing communities at the present time, rapidly displacing such longtime stalwarts as R when it comes to these applications. It too, however, is also put to a myriad of other uses, and the two languages probably vie for the title when it comes to how flexible their users find them.

A Matter of Personality...

That isn't to say that there aren't some major, immediately noticeable, differences between the two programming tongues. Ruby is famous for its flexibility and eagerness to please; it is seen by many as a cleaned-up continuation of Perl's "Do What I Mean" philosophy, whereby the interpreter does its best to figure out the meaning of evening non-canonical syntactic constructs. In fact, the language's creator, Yukihiro Matsumoto, chose his brainchild's name in homage to that earlier language's gemstone-inspired moniker.

Python, on the other hand, takes a very different tact. In a famous Python Enhancement Proposal called "The Zen of Python," longtime Pythonista Tim Peters declared it to be preferable that there should only be a single obvious way to do anything. Python enthusiasts and programmers, then, generally prize unanimity of style over syntactic flexibility compared to those who choose Ruby, and this shows in the code they create. Even Python's whitespace-sensitive parsing has a feel of lending clarity through syntactical enforcement that is very much at odds with the much fuzzier style of typical Ruby code.

For example, Python's much-admired list comprehension feature serves as the most obvious way to build up certain kinds of lists according to initial conditions:

a = [x**3 for x in range(10,20)]
b = [y for y in a if y % 2 == 0]

first builds up a list of the cubes of all of the numbers between 10 and 19 (yes, 19), assigning the result to 'a'. A second list of those elements in 'a' which are even is then stored in 'b'. One natural way to do this in Ruby is probably:

a = (10..19).map {|x| x ** 3}
b = a.select {|y| y.even?}

but there are a number of obvious alternatives, such as:

a = (10..19).collect do |x|
x ** 3
end

b = a.find_all do |y|
y % 2 == 0
end

It tends to be a little easier to come up with equally viable, but syntactically distinct, solutions in Ruby compared to Python, even for relatively simple tasks like the above. That is not to say that Ruby is a messy language, either; it is merely that it is somewhat freer and more forgiving than Python is, and many consider Python's relative purity in this regard a real advantage when it comes to writing clear, easily understandable code.

And Somewhat One of Performance

I will begin our blog on Java Tutorial with an incredibly important aspect of java development:  memory management.  The importance of this topic should not be minimized as an application's performance and footprint size are at stake.

From the outset, the Java Virtual Machine (JVM) manages memory via a mechanism known as Garbage Collection (GC).  The Garbage collector

• Manages the heap memory.   All obects are stored on the heap; therefore, all objects are managed.  The keyword, new, allocates the requisite memory to instantiate an object and places the newly allocated memory on the heap.  This object is marked as live until it is no longer being reference.
• Deallocates or reclaims those objects that are no longer being referened. 
• Traditionally, employs a Mark and Sweep algorithm.  In the mark phase, the collector identifies which objects are still alive.  The sweep phase identifies objects that are no longer alive.
• Deallocates the memory of objects that are not marked as live.
• Is automatically run by the JVM and not explicitely called by the Java developer.  Unlike languages such as C++, the Java developer has no explict control over memory management.
• Does not manage the stack.  Local primitive types and local object references are not managed by the GC.

So if the Java developer has no control over memory management, why even worry about the GC?  It turns out that memory management is an integral part of an application's performance, all things being equal.  The more memory that is required for the application to run, the greater the likelihood that computational efficiency suffers. To that end, the developer has to take into account the amount of memory being allocated when writing code.  This translates into the amount of heap memory being consumed.

Memory is split into two types:  stack and heap.  Stack memory is memory set aside for a thread of execution e.g. a function.  When a function is called, a block of memory is reserved for those variables local to the function, provided that they are either a type of Java primitive or an object reference.  Upon runtime completion of the function call, the reserved memory block is now available for the next thread of execution.  Heap memory, on the otherhand, is dynamically allocated.  That is, there is no set pattern for allocating or deallocating this memory.  Therefore, keeping track or managing this type of memory is a complicated process. In Java, such memory is allocated when instantiating an object:

String s = new String();  // new operator being employed
String m = "A String";    /* object instantiated by the JVM and then being set to a value.  The JVM
calls the new operator */

In this tutorial I am going to give you a gentle introduction to network programming in Python. If you are new to programming or new to Python then that may seem like a daunting thought. But read on and you will be pleasantly surprised how easy it is.

Like most modern programming languages, Python was designed for networking from the very beginning, and thanks to that, a lot of the networking tasks you would want to accomplish with the language are made a whole lot easier.

Network communication is a large topic, but if it is something that interests you then read on because in this tutorial I will show you how to download a web page. I will show you how easy Python makes tasks like this.

Take a look at the following code:

import urllib
	
con = urllib.urlopen("http://hartmannsoftware.com")
page = con.read()
con.close()
print page