Loops and Locks
This article is regarding Loops and Locks. And about the performance of our code. There is no ‘silver bullet’ to making fast and efficient code...let's do it ourself.
AI
AI Samenvatting: This codebase represents a historical implementation of the logic described in the metadata. Our preservation engine analyzes the structure to provide context for modern developers.
Broncode
<html xmlns:o="urn:schemas-microsoft-com:office:office"
xmlns:w="urn:schemas-microsoft-com:office:word"
xmlns:st1="urn:schemas-microsoft-com:office:smarttags"
xmlns="http://www.w3.org/TR/REC-html40">
<head>
<meta http-equiv=Content-Type content="text/html; charset=windows-1252">
<meta name=ProgId content=Word.Document>
<meta name=Generator content="Microsoft Word 10">
<meta name=Originator content="Microsoft Word 10">
<link rel=File-List href="Programming%20Efficient%20Code_files/filelist.xml">
<title>Programming Efficient Code</title>
<o:SmartTagType namespaceuri="urn:schemas-microsoft-com:office:smarttags"
name="place"/>
<!--[if gte mso 9]><xml>
<o:DocumentProperties>
<o:Author>default</o:Author>
<o:LastAuthor>default</o:LastAuthor>
<o:Revision>1</o:Revision>
<o:TotalTime>2</o:TotalTime>
<o:Created>2002-05-29T06:35:00Z</o:Created>
<o:LastSaved>2002-05-29T06:37:00Z</o:LastSaved>
<o:Pages>1</o:Pages>
<o:Words>1110</o:Words>
<o:Characters>6331</o:Characters>
<o:Lines>52</o:Lines>
<o:Paragraphs>14</o:Paragraphs>
<o:CharactersWithSpaces>7427</o:CharactersWithSpaces>
<o:Version>10.2625</o:Version>
</o:DocumentProperties>
</xml><![endif]--><!--[if gte mso 9]><xml>
<w:WordDocument>
<w:Compatibility>
<w:BreakWrappedTables/>
<w:SnapToGridInCell/>
<w:WrapTextWithPunct/>
<w:UseAsianBreakRules/>
</w:Compatibility>
<w:BrowserLevel>MicrosoftInternetExplorer4</w:BrowserLevel>
</w:WordDocument>
</xml><![endif]--><!--[if !mso]><object
classid="clsid:38481807-CA0E-42D2-BF39-B33AF135CC4D" id=ieooui></object>
<style>
st1\:*{behavior:url(#ieooui) }
</style>
<![endif]-->
<style>
<!--
/* Font Definitions */
@font-face
{font-family:Courier;
panose-1:2 7 4 9 2 2 5 2 4 4;
mso-font-alt:"Courier New";
mso-font-charset:0;
mso-generic-font-family:modern;
mso-font-format:other;
mso-font-pitch:fixed;
mso-font-signature:3 0 0 0 1 0;}
/* Style Definitions */
p.MsoNormal, li.MsoNormal, div.MsoNormal
{mso-style-parent:"";
margin:0in;
margin-bottom:.0001pt;
mso-pagination:widow-orphan;
font-size:12.0pt;
font-family:"Times New Roman";
mso-fareast-font-family:"Times New Roman";}
a:link, span.MsoHyperlink
{color:blue;
text-decoration:underline;
text-underline:single;}
a:visited, span.MsoHyperlinkFollowed
{color:purple;
text-decoration:underline;
text-underline:single;}
code
{font-family:Courier;
mso-ascii-font-family:Courier;
mso-fareast-font-family:"Times New Roman";
mso-hansi-font-family:Courier;
mso-bidi-font-family:"Courier New";}
pre
{margin:0in;
margin-bottom:.0001pt;
mso-pagination:widow-orphan;
font-size:10.0pt;
font-family:"Courier New";
mso-fareast-font-family:"Times New Roman";}
@page Section1
{size:8.5in 11.0in;
margin:1.0in 1.25in 1.0in 1.25in;
mso-header-margin:.5in;
mso-footer-margin:.5in;
mso-paper-source:0;}
div.Section1
{page:Section1;}
-->
</style>
<!--[if gte mso 10]>
<style>
/* Style Definitions */
table.MsoNormalTable
{mso-style-name:"Table Normal";
mso-tstyle-rowband-size:0;
mso-tstyle-colband-size:0;
mso-style-noshow:yes;
mso-style-parent:"";
mso-padding-alt:0in 5.4pt 0in 5.4pt;
mso-para-margin:0in;
mso-para-margin-bottom:.0001pt;
mso-pagination:widow-orphan;
font-size:10.0pt;
font-family:"Times New Roman";}
</style>
<![endif]-->
</head>
<body lang=EN-US link=blue vlink=purple style='tab-interval:.5in'>
<div class=Section1>
<p class=MsoNormal><b><span style='font-size:16.0pt;font-family:Arial'>Programming
Efficient Code</span></b><o:p></o:p></p>
<p class=MsoNormal><b><span style='font-size:11.0pt;font-family:Arial'>Loops
and Locks<o:p></o:p></span></b></p>
<p class=MsoNormal><span style='font-size:9.0pt;font-family:Arial'>Article by </span><i><span
style='font-size:10.0pt;font-family:Arial'>Sachin Mehra (<a
href="mailto:sachinweb@hotmail.com">sachinweb@hotmail.com</a>)<o:p></o:p></span></i></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>One of the
worst things that a programmer can assume is that the compiler and middleware
will do the optimizations for you! Most applications are being targeted for
50-200 concurrent users, which is why we need to constantly be worrying about
the performance of our code. </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>Say you
have a search component (which will be on everybody’s desktop) which takes 3-5
seconds to load; and consequently ties down the database. Imagine what
will happen when 200 people try to load this at the same time. Simple
math would suggest (say using an average of 4 seconds): (4 x 200) / 60 = 13 –
THAT’S 13 MINUTES! And actually, when dealing with situations of high
contention, you cannot assume 100% efficiency and could be realistically
dealing with something in the range of 20-25 minutes of processing time
required. </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>There is no
‘silver bullet’ to making fast and efficient code. Middleware will not
solve the problem for you, databases will not solve the problem for you, it is
up to you as a computational process engineer (how’s that for a title?) to
understand and deal with the underlying inefficiencies in the software you
design. There are many things which you need to consider, and you need to
think your logic out carefully. One thing you should always be asking
yourself is “could this be done better?”.</span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>In
programming, we find ourselves in loops a lot. In Java, we especially
find ourselves looping through </span><span style='font-size:10.0pt;font-family:
"Courier New"'>Collection</span><span style='font-size:10.0pt;font-family:Arial'>
objects an awful lot. This is one of the particular areas where many of
us need some improvement. When you use a </span><span style='font-size:
10.0pt;font-family:"Courier New"'>Collection</span><span style='font-size:10.0pt;
font-family:Arial'> object, how do you decide what type of </span><span
style='font-size:10.0pt;font-family:"Courier New"'>Collection</span><span
style='font-size:10.0pt;font-family:Arial'> to use, and how to apply it?
It seems to me that most Java Programmers are just using “whatever works”, and
they use the one which they “believe” to be the fastest. The fact of the
matter is, different types of collections are for different kinds of
applications. Do you truly know the differences between </span><span
style='font-size:10.0pt;font-family:"Courier New"'>Vector</span><span
style='font-size:10.0pt;font-family:Arial'> and </span><span style='font-size:
10.0pt;font-family:"Courier New"'>ArrayList. </span><span
style='font-size:10.0pt;font-family:Arial'>The most common misconception I have
heard is that a </span><span style='font-size:10.0pt;font-family:"Courier New"'>Vector
</span><span style='font-size:10.0pt;font-family:Arial'>will automatically grow
in size, and an </span><span style='font-size:10.0pt;font-family:"Courier New"'>ArrayList</span><span
style='font-size:10.0pt;font-family:Arial'> will not, this is simply not
true. The only real difference is that </span><span style='font-size:
10.0pt;font-family:"Courier New"'>Vector</span><span style='font-size:10.0pt;
font-family:Arial'> is thread-safe and </span><span style='font-size:10.0pt;
font-family:"Courier New"'>ArrayList</span><span style='font-size:10.0pt;
font-family:Arial'> is not. And what does this mean?</span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>Being
thread-safe is not always a good thing. When something is thread safe, it
means that the runtime must maintain locks on certain objects, when they are
being accessed to prevent concurrent modification. In many cases, this
additional check is unnecessary and very costly to performance. On the
other hand there are situations where it is very necessary to do thread-safe
operations. Many people understand the jist of synchronization, but don’t
truly understand how to take advantage of it properly. One thing I
have see people doing a lot is applying </span><span style='font-size:10.0pt;
font-family:"Courier New"'>synchronized</span><span style='font-size:10.0pt;
font-family:Arial'> in places where they should not. Consider the following:</span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><b><span style='font-size:10.0pt;font-family:Arial'>Example
1A</span></b><span style='font-size:10.0pt;font-family:Arial'>:</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>synchronized void addUser(User user) {<br>
this.list.add(user);</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>}</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>Another
common misconception is that the </span><span style='font-size:10.0pt;
font-family:"Courier New"'>synchronized</span><span style='font-size:10.0pt;
font-family:Arial'> keyword will only protect that particular method. If
you think this, you should read on. This will however, effectively only
allow the instance of </span><span style='font-size:10.0pt;font-family:"Courier New"'>list</span><span
style='font-size:10.0pt;font-family:Arial'> to be accessed by only one Thread
at a time. But by doing this, you force the runtime to place a lock on the
entire object pool of the class instance, which essentially means, any instance
methods cannot be executed during the execution of </span><span
style='font-size:10.0pt;font-family:"Courier New"'>addUser().</span><span
style='font-size:10.0pt;font-family:Arial'> In most cases, this is
inefficient. Other threads may need access to other non-effected
items. </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>The
following example addresses this problem.</span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><b><span style='font-size:10.0pt;font-family:Arial'>Example
2A</span></b><span style='font-size:10.0pt;font-family:Arial'>:</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>void adduUser(User user) {</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>
synchronized (this.list) {</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>
this.list.add(user)</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>
}</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>}</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>In this
example, we only lock the instance of </span><span style='font-size:10.0pt;
font-family:"Courier New"'>list</span><span style='font-size:10.0pt;font-family:
Arial'> for the duration of the </span><span style='font-size:10.0pt;
font-family:"Courier New"'>add()</span><span style='font-size:10.0pt;
font-family:Arial'> execution. This is much more efficient than Example
1A.</span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>Now what
does this have to do with picking </span><span style='font-size:10.0pt;
font-family:"Courier New"'>ArrayList</span><span style='font-size:10.0pt;
font-family:Arial'> or </span><span style='font-size:10.0pt;font-family:"Courier New"'>Vector</span><span
style='font-size:10.0pt;font-family:Arial'>? Well a lot really. In
instances where we are dealing with temporary sets of data or method-scoped
instances, using a </span><span style='font-size:10.0pt;font-family:"Courier New"'>Vector</span><span
style='font-size:10.0pt;font-family:Arial'> is very inefficient. In
situations where there is no chance of their being concurrent access, you
should most certainly choose an </span><span style='font-size:10.0pt;
font-family:"Courier New"'>ArrayList</span><span style='font-size:10.0pt;
font-family:Arial'>. For using a </span><span style='font-size:10.0pt;
font-family:"Courier New"'>Vector</span><span style='font-size:10.0pt;
font-family:Arial'> would serve absolutely no useful purpose, and would provide
unnecessary lock-checking. We’ll leave hashed-collections for later :).</span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><st1:place><b><span style='font-family:Arial'>Loop</span></b></st1:place><b><span
style='font-family:Arial'> Iteration and Tail Recursion</span></b><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>As we said
earlier, our programs spend a lot of time in loops, and unfortunately loose a
lot of their performance in them as well. I will try to cover a few
pointers which may help you in certain situations shave some unnecessary
computational cycles off you’re code.</span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>People tend
to think from beginning to end, and they tend to program in this forward
lineage as well. But this can often be inefficient. Sometimes the
computer can find its way from the end to the beginning much faster. </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>Consider
the code in Example 1.</span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><b><span style='font-size:10.0pt;font-family:Arial'>Example
1B</span></b><span style='font-size:10.0pt;font-family:Arial'>:</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:9.0pt;
font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:9.0pt;
font-family:Arial'>for (int i = 0; i < arrayList.size(); i++) {</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:9.0pt;
font-family:Arial'>
Object obj = (Object) object.get(i);</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:9.0pt;
font-family:Arial'>
obj.doSomething();</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:9.0pt;
font-family:Arial'>}</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:9.0pt;
font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>This is a
fairly straight-forward for-loop to iterate that iterates through an entire
collection to do something. But consider Example 2:</span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><b><span style='font-size:10.0pt;font-family:Arial'>Example
2B</span></b><span style='font-size:10.0pt;font-family:Arial'>:</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E6E6E6'><span style='font-size:10.0pt;
font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal style='background:#E6E6E6'><span style='font-size:10.0pt;
font-family:Arial'>for (int i = arrayList.size(); i != 0; i--) {</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E6E6E6'><span style='font-size:10.0pt;
font-family:Arial'>
Object obj = (Object) object.get(i);</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E6E6E6'><span style='font-size:10.0pt;
font-family:Arial'>
Obj.doSomething();</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E6E6E6'><span style='font-size:10.0pt;
font-family:Arial'>}</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E6E6E6'><span style='font-size:10.0pt;
font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>This
example is many times more efficient than Example 1. In example one, we
are making a call to </span><span style='font-size:9.0pt;font-family:"Courier New"'>arrayList.size()</span><span
style='font-size:10.0pt;font-family:Arial'> for every iteration through the
loop which is unnecessary, and also we are doing a direct XAND comparison to
determine if the loop should continue which is also more efficient. By
looping backwards through the </span><span style='font-size:10.0pt;font-family:
"Courier New"'>ArrayList</span><span style='font-size:10.0pt;font-family:Arial'>
we manage to increase processing efficiency but 50% or more! </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>Another
magical method to performing ultra-efficient loops has been long-since
forgotten. Yes, I am talking about “tail recursion”. This is one of
the best ways to do mathematical sums on large lists. It also works brilliantly
with Java’s </span><span style='font-size:10.0pt;font-family:"Courier New"'>Iterator</span><span
style='font-size:10.0pt;font-family:Arial'> and </span><span style='font-size:
10.0pt;font-family:"Courier New"'>Enumeration</span><span style='font-size:
10.0pt;font-family:Arial'> interfaces. Consider the following example:</span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><b><span style='font-size:10.0pt;font-family:Arial'>Example
1C:</span></b><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>public int getRecordsSum(Iterator iter) {</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>
return _getRecordsSum(iter, 1);</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>}</span><o:p></o:p></p>
<pre style='background:#E0E0E0'><span style='font-family:Arial'> </span><o:p></o:p></pre><pre
style='background:#E0E0E0'><span style='font-family:Arial'>public int _getRecordsSum(Iterator iter, int counter) {<br
style='mso-special-character:line-break'>
<![if !supportLineBreakNewLine]><br style='mso-special-character:line-break'>
<![endif]><o:p></o:p></span></pre><pre style='background:#E0E0E0'><span
style='font-family:Arial'> if (iter.hasNext() {<br
style='mso-special-character:line-break'>
<![if !supportLineBreakNewLine]><br style='mso-special-character:line-break'>
<![endif]><o:p></o:p></span></pre><pre style='background:#E0E0E0'><span
style='font-family:Arial'> </span><code><span
style='font-size:9.0pt'>return _getRecordsSum(iter, counter + ((Integer)i.next()).intValue());</span></code><o:p></o:p></pre>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>
}</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>
else {</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>
return counter;</span><o:p></o:p></p>
<p class=MsoNormal style='text-indent:.5in;background:#E0E0E0'><span
style='font-size:10.0pt;font-family:Arial'>}</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'>}</span><o:p></o:p></p>
<p class=MsoNormal style='background:#E0E0E0'><span style='font-size:10.0pt;
font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>Now for
those of you who are keen, you might be thinking </span><span style='font-size:
10.0pt;font-family:"Courier New"'>StackOverflowException</span><span
style='font-size:10.0pt;font-family:Arial'> here. But actually, the
compiler will see the optimization opportunity here, just as C and C++
compilers will. The compiler will pick up on the tail recursion based on
the fact that </span><span style='font-size:10.0pt;font-family:"Courier New"'>_getRecordsSum()</span><span
style='font-size:10.0pt;font-family:Arial'> contains no method variables, and
is passing references back into itself. Therefore, this will not cause a
run-away stack, but rather a very efficient way of processing numbers. </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><b><span style='font-family:Arial'>Final Words</span></b><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'>Programming
is all about problem solving. And as with other kinds of problem solving,
there are always many different ways to solve the problem. However, some
ways are more certainly better than others. You should take the time to
understand how the underlying components you are using actually work, and why
they work they way they do.</span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><span style='font-size:10.0pt;font-family:Arial'> </span><o:p></o:p></p>
<p class=MsoNormal><i><span style='font-size:10.0pt;font-family:Arial'>Article
By Sachin Mehra (sachinweb@hotmail.com) </span></i><o:p></o:p></p>
<p class=MsoNormal><o:p> </o:p></p>
</div>
</body>
</html>
Upload
Originele reacties (3)
Hersteld van de Wayback Machine