<article>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#article10_02_19_147251</id>
	<title>What Knowledge Gaps Do Self-Taught Programmers Generally Have?</title>
	<author>ScuttleMonkey</author>
	<datestamp>1266591180000</datestamp>
	<htmltext>BeardedChimp writes <i>"I, like many others here, have learned to program by myself.  Starting at a young age and learning through fiddling I have taught myself C++, Java, python, PHP, etc., but what I want to know is what I haven't learned that is important when taught in a traditional computer science curriculum. I have a degree in physics, so I'm not averse to math. What books, websites, or resources would you recommend to fill in the gaps?"</i></htmltext>
<tokenext>BeardedChimp writes " I , like many others here , have learned to program by myself .
Starting at a young age and learning through fiddling I have taught myself C + + , Java , python , PHP , etc. , but what I want to know is what I have n't learned that is important when taught in a traditional computer science curriculum .
I have a degree in physics , so I 'm not averse to math .
What books , websites , or resources would you recommend to fill in the gaps ?
"</tokentext>
<sentencetext>BeardedChimp writes "I, like many others here, have learned to program by myself.
Starting at a young age and learning through fiddling I have taught myself C++, Java, python, PHP, etc., but what I want to know is what I haven't learned that is important when taught in a traditional computer science curriculum.
I have a degree in physics, so I'm not averse to math.
What books, websites, or resources would you recommend to fill in the gaps?
"</sentencetext>
</article>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202232</id>
	<title>A good foundation</title>
	<author>Calsar</author>
	<datestamp>1266609120000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I may be somewhat biased since I have a BS and MS in Computer Science.  Computer Science gives you a good foundation to understanding what is going on behind the scenes.  More understanding is better.  There are libraries and built in functions for just about everything these days which anybody can use, but you are better able to diagnose problems when something goes wrong if you have a deeper understanding of how they work.</p><p>A recent CS grad and a self taught developer with 4 years of experience are not at the same level.  The self taught person is generally going to be better at writing applications.  However, in the long run a person with a CS degree will surpass the self taught person.  This of course assumes equal levels of talent.  About 10\% of developers are just better than the rest by an order of magnitude or more.</p><p>I learned a lot in school that isn&rsquo;t particularly useful for my job.  For instance, no one has asked me to write an application to solve differential equations.  I did have to write a quick sort in basic when I first graduated.  I also ran into an issue recently where a client had some equations they wanted coded into an application for reporting.  I had a self taught developer who just looked at it and had no clue.  I coded the equations into a function for him so he could finish the report.</p></htmltext>
<tokenext>I may be somewhat biased since I have a BS and MS in Computer Science .
Computer Science gives you a good foundation to understanding what is going on behind the scenes .
More understanding is better .
There are libraries and built in functions for just about everything these days which anybody can use , but you are better able to diagnose problems when something goes wrong if you have a deeper understanding of how they work.A recent CS grad and a self taught developer with 4 years of experience are not at the same level .
The self taught person is generally going to be better at writing applications .
However , in the long run a person with a CS degree will surpass the self taught person .
This of course assumes equal levels of talent .
About 10 \ % of developers are just better than the rest by an order of magnitude or more.I learned a lot in school that isn    t particularly useful for my job .
For instance , no one has asked me to write an application to solve differential equations .
I did have to write a quick sort in basic when I first graduated .
I also ran into an issue recently where a client had some equations they wanted coded into an application for reporting .
I had a self taught developer who just looked at it and had no clue .
I coded the equations into a function for him so he could finish the report .</tokentext>
<sentencetext>I may be somewhat biased since I have a BS and MS in Computer Science.
Computer Science gives you a good foundation to understanding what is going on behind the scenes.
More understanding is better.
There are libraries and built in functions for just about everything these days which anybody can use, but you are better able to diagnose problems when something goes wrong if you have a deeper understanding of how they work.A recent CS grad and a self taught developer with 4 years of experience are not at the same level.
The self taught person is generally going to be better at writing applications.
However, in the long run a person with a CS degree will surpass the self taught person.
This of course assumes equal levels of talent.
About 10\% of developers are just better than the rest by an order of magnitude or more.I learned a lot in school that isn’t particularly useful for my job.
For instance, no one has asked me to write an application to solve differential equations.
I did have to write a quick sort in basic when I first graduated.
I also ran into an issue recently where a client had some equations they wanted coded into an application for reporting.
I had a self taught developer who just looked at it and had no clue.
I coded the equations into a function for him so he could finish the report.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201162</id>
	<title>Read What the Classes Use</title>
	<author>MrTripps</author>
	<datestamp>1266603600000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Ours uses ADTs, Data Structures, and Problem Solving with C++ Second Edition by Larry Nyhoff. It may be too simplistic for an accomplished amateur, but it does go beyond basic control structures. You can get previous editions of used text books fairly cheap. There usually isn't much new in a new edition. It is mostly a scam to enrich text book producers.</htmltext>
<tokenext>Ours uses ADTs , Data Structures , and Problem Solving with C + + Second Edition by Larry Nyhoff .
It may be too simplistic for an accomplished amateur , but it does go beyond basic control structures .
You can get previous editions of used text books fairly cheap .
There usually is n't much new in a new edition .
It is mostly a scam to enrich text book producers .</tokentext>
<sentencetext>Ours uses ADTs, Data Structures, and Problem Solving with C++ Second Edition by Larry Nyhoff.
It may be too simplistic for an accomplished amateur, but it does go beyond basic control structures.
You can get previous editions of used text books fairly cheap.
There usually isn't much new in a new edition.
It is mostly a scam to enrich text book producers.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31208658</id>
	<title>Huge skill deficits</title>
	<author>HW\_Hack</author>
	<datestamp>1266658140000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>- Don't have the training to survive multiple 2-4hr meetings every week<br>- Have not been forced to work with coding morons<br>- No skills in creating weasel-word specifications or slide sets</p><p>- And the biggest of all - Will not be able to hang by the water cooler and compare the college you went to with the other geeks</p></htmltext>
<tokenext>- Do n't have the training to survive multiple 2-4hr meetings every week- Have not been forced to work with coding morons- No skills in creating weasel-word specifications or slide sets- And the biggest of all - Will not be able to hang by the water cooler and compare the college you went to with the other geeks</tokentext>
<sentencetext>- Don't have the training to survive multiple 2-4hr meetings every week- Have not been forced to work with coding morons- No skills in creating weasel-word specifications or slide sets- And the biggest of all - Will not be able to hang by the water cooler and compare the college you went to with the other geeks</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200152</id>
	<title>Learn by example</title>
	<author>subanark</author>
	<datestamp>1266599280000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I find that many self-taught programmers learn by example. They copy a bit of code here, and modify it to suit their needs. The problem with this is they often do not understand why the code segments work the way they do. For example, I see a lot of Java programmers with the misconception that the 'import' statement is equivalent to C's #include statement (rather than the using statement). They know that if I 'import java.util.*' I can use the classes in the java.util package. Instead what they should say is: I can write the short form of classes in java.util.</p><p>For this same reason, I find a lot of beginner programmers confused on instance methods vs static or global methods. As Java does not have global methods, the simpler to understand static methods require an additional keyword to use. Many Java programmers will start out with applets, where the starting point is an instance method, and then try to transition to applications where the main method is static and wonder why they can't call instance methods from their main method.</p></htmltext>
<tokenext>I find that many self-taught programmers learn by example .
They copy a bit of code here , and modify it to suit their needs .
The problem with this is they often do not understand why the code segments work the way they do .
For example , I see a lot of Java programmers with the misconception that the 'import ' statement is equivalent to C 's # include statement ( rather than the using statement ) .
They know that if I 'import java.util .
* ' I can use the classes in the java.util package .
Instead what they should say is : I can write the short form of classes in java.util.For this same reason , I find a lot of beginner programmers confused on instance methods vs static or global methods .
As Java does not have global methods , the simpler to understand static methods require an additional keyword to use .
Many Java programmers will start out with applets , where the starting point is an instance method , and then try to transition to applications where the main method is static and wonder why they ca n't call instance methods from their main method .</tokentext>
<sentencetext>I find that many self-taught programmers learn by example.
They copy a bit of code here, and modify it to suit their needs.
The problem with this is they often do not understand why the code segments work the way they do.
For example, I see a lot of Java programmers with the misconception that the 'import' statement is equivalent to C's #include statement (rather than the using statement).
They know that if I 'import java.util.
*' I can use the classes in the java.util package.
Instead what they should say is: I can write the short form of classes in java.util.For this same reason, I find a lot of beginner programmers confused on instance methods vs static or global methods.
As Java does not have global methods, the simpler to understand static methods require an additional keyword to use.
Many Java programmers will start out with applets, where the starting point is an instance method, and then try to transition to applications where the main method is static and wonder why they can't call instance methods from their main method.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200004</id>
	<title>Usability studies</title>
	<author>Anonymous</author>
	<datestamp>1266598560000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>This is a must for programmers - And soooo few know how to do it. It's all fine and dandy that you can find your way around the interface that you designed, but you need to realize that not everyone thinks like you. I was fortunate enough to take a course in it while studying, and I think I was one out of a handful that didn't say "This is useless" and in some cases people were even outright hostile to the idea of usability. It applies not only to UIs, but also to APIs and code, too. Usability is about how you grease your work so it runs smoothly for everyone, not just you. In the case of coders it lets them become fluid in your API easier.</p></htmltext>
<tokenext>This is a must for programmers - And soooo few know how to do it .
It 's all fine and dandy that you can find your way around the interface that you designed , but you need to realize that not everyone thinks like you .
I was fortunate enough to take a course in it while studying , and I think I was one out of a handful that did n't say " This is useless " and in some cases people were even outright hostile to the idea of usability .
It applies not only to UIs , but also to APIs and code , too .
Usability is about how you grease your work so it runs smoothly for everyone , not just you .
In the case of coders it lets them become fluid in your API easier .</tokentext>
<sentencetext>This is a must for programmers - And soooo few know how to do it.
It's all fine and dandy that you can find your way around the interface that you designed, but you need to realize that not everyone thinks like you.
I was fortunate enough to take a course in it while studying, and I think I was one out of a handful that didn't say "This is useless" and in some cases people were even outright hostile to the idea of usability.
It applies not only to UIs, but also to APIs and code, too.
Usability is about how you grease your work so it runs smoothly for everyone, not just you.
In the case of coders it lets them become fluid in your API easier.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200652</id>
	<title>Repositories, code reviews, flexibility</title>
	<author>Fastolfe</author>
	<datestamp>1266601260000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>1. Learn how to use source code repositories (including branching, merging, and resolving conflicts), and how organizations do releases<br>2. Learn how to do code reviews, and how to adapt to local practices and style guides.<br>3. Learn how to be flexible.<br>4. Be humble.</p><p>Self-taught programmers frequently develop and religiously stick to their own favorite practices, code formatting, programming languages, IDEs, etc.  When you're part of a team, though, your code needs to be readable, understandable and maintainable by other members of the team.  This means learning how to be flexible and work effectively outside of your favorite language/environment.  Some of this you can get by participating in some open source projects, and active participation in open source projects is something I look for on resumes when a candidate seems to be self-taught.</p></htmltext>
<tokenext>1 .
Learn how to use source code repositories ( including branching , merging , and resolving conflicts ) , and how organizations do releases2 .
Learn how to do code reviews , and how to adapt to local practices and style guides.3 .
Learn how to be flexible.4 .
Be humble.Self-taught programmers frequently develop and religiously stick to their own favorite practices , code formatting , programming languages , IDEs , etc .
When you 're part of a team , though , your code needs to be readable , understandable and maintainable by other members of the team .
This means learning how to be flexible and work effectively outside of your favorite language/environment .
Some of this you can get by participating in some open source projects , and active participation in open source projects is something I look for on resumes when a candidate seems to be self-taught .</tokentext>
<sentencetext>1.
Learn how to use source code repositories (including branching, merging, and resolving conflicts), and how organizations do releases2.
Learn how to do code reviews, and how to adapt to local practices and style guides.3.
Learn how to be flexible.4.
Be humble.Self-taught programmers frequently develop and religiously stick to their own favorite practices, code formatting, programming languages, IDEs, etc.
When you're part of a team, though, your code needs to be readable, understandable and maintainable by other members of the team.
This means learning how to be flexible and work effectively outside of your favorite language/environment.
Some of this you can get by participating in some open source projects, and active participation in open source projects is something I look for on resumes when a candidate seems to be self-taught.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200104</id>
	<title>Depends...</title>
	<author>Anonymous</author>
	<datestamp>1266599040000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Depends on how you're self taught.  School teaches you primarily from books.  Self taught people, most of the time, learn things from books.  The difference is that self taught people don't get the benefit from the great teachers with years of knowledge and wisdom.  They also don't have to deal with idiotic teachers who don't even understand what they're teaching (and YES, they DO exist even at the masters level of instruction).</p></htmltext>
<tokenext>Depends on how you 're self taught .
School teaches you primarily from books .
Self taught people , most of the time , learn things from books .
The difference is that self taught people do n't get the benefit from the great teachers with years of knowledge and wisdom .
They also do n't have to deal with idiotic teachers who do n't even understand what they 're teaching ( and YES , they DO exist even at the masters level of instruction ) .</tokentext>
<sentencetext>Depends on how you're self taught.
School teaches you primarily from books.
Self taught people, most of the time, learn things from books.
The difference is that self taught people don't get the benefit from the great teachers with years of knowledge and wisdom.
They also don't have to deal with idiotic teachers who don't even understand what they're teaching (and YES, they DO exist even at the masters level of instruction).</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200946</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>Anonymous</author>
	<datestamp>1266602760000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>This was exactly my first thought. All the education in the world can't compensate for lack of interest. There's nothing I fear more at work than somebody who really doesn't care about the code.</htmltext>
<tokenext>This was exactly my first thought .
All the education in the world ca n't compensate for lack of interest .
There 's nothing I fear more at work than somebody who really does n't care about the code .</tokentext>
<sentencetext>This was exactly my first thought.
All the education in the world can't compensate for lack of interest.
There's nothing I fear more at work than somebody who really doesn't care about the code.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200206</id>
	<title>Maintenance programming</title>
	<author>Anonymous</author>
	<datestamp>1266599520000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext><p>I'd say that formally taught programmers may not have much experience with maintenance programming, especially with legacy systems that have been running for years.  They are used to 'blank sheet' programming assignments that allow them to control the entire project from start to finish.  They don't have to deal with code that has been modified dozens of times over the years, often without much documentation.</p><p>I got my professional start in programming doing maintenance programming under the supervision of a senior programmer who had spent years working with the systems as they evolved.  While I had done some programming in college, all 'blank sheet' stuff, doing maintenance programming was much more educational.  You had to make sure that things were done right, otherwise you could cause big, real world problems.</p></htmltext>
<tokenext>I 'd say that formally taught programmers may not have much experience with maintenance programming , especially with legacy systems that have been running for years .
They are used to 'blank sheet ' programming assignments that allow them to control the entire project from start to finish .
They do n't have to deal with code that has been modified dozens of times over the years , often without much documentation.I got my professional start in programming doing maintenance programming under the supervision of a senior programmer who had spent years working with the systems as they evolved .
While I had done some programming in college , all 'blank sheet ' stuff , doing maintenance programming was much more educational .
You had to make sure that things were done right , otherwise you could cause big , real world problems .</tokentext>
<sentencetext>I'd say that formally taught programmers may not have much experience with maintenance programming, especially with legacy systems that have been running for years.
They are used to 'blank sheet' programming assignments that allow them to control the entire project from start to finish.
They don't have to deal with code that has been modified dozens of times over the years, often without much documentation.I got my professional start in programming doing maintenance programming under the supervision of a senior programmer who had spent years working with the systems as they evolved.
While I had done some programming in college, all 'blank sheet' stuff, doing maintenance programming was much more educational.
You had to make sure that things were done right, otherwise you could cause big, real world problems.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201812</id>
	<title>I don't know what I don't know.</title>
	<author>Dragnl0rd</author>
	<datestamp>1266606600000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Being self taught, one of the major revelations I had was that the more I tried to teach myself, the more I realized I knew just a FRACTION of what it took to become a good developer.  In the beginning when I thought I understood what i was doing, writing oop programs, when in fact I was writing procedural code with objects scattered around it.  Regular Expressions were (to me) among the arcane arts known by masters, engines were something to be licensed from those same masters, and I didn't even hear the words "design pattern" until I'd been trying to work professionally for over a year.  Many of the things I know today, I wouldn't have even known to ask/research/learn about back then, because I couldn't conceive of its existence.  Heck, I'll probably be saying that forever!  To quote a friend of mine:  "I cannot grasp the depth of my own ignorance."

However, while doing the 'self taught' thing, I have seen other threads like this recommending the staple books like the Petzold book for windows programming, the O'Reilly series, the Stroustrup book for C++, and the "Head First Design Patterns" book.  However since i still have google up when doing the vast majority of my coding, I've actually found that more and more I've been bookmarking blogs by developers more experienced and skilled than myself.  Moreso than most books, the blogs I keep bookmarked tend to have prefaces at the beginning of each article explaining exactly what programming obstacle the blogger had encountered, thus providing a concrete application for the code to follow in that article.</div>
	</htmltext>
<tokenext>Being self taught , one of the major revelations I had was that the more I tried to teach myself , the more I realized I knew just a FRACTION of what it took to become a good developer .
In the beginning when I thought I understood what i was doing , writing oop programs , when in fact I was writing procedural code with objects scattered around it .
Regular Expressions were ( to me ) among the arcane arts known by masters , engines were something to be licensed from those same masters , and I did n't even hear the words " design pattern " until I 'd been trying to work professionally for over a year .
Many of the things I know today , I would n't have even known to ask/research/learn about back then , because I could n't conceive of its existence .
Heck , I 'll probably be saying that forever !
To quote a friend of mine : " I can not grasp the depth of my own ignorance .
" However , while doing the 'self taught ' thing , I have seen other threads like this recommending the staple books like the Petzold book for windows programming , the O'Reilly series , the Stroustrup book for C + + , and the " Head First Design Patterns " book .
However since i still have google up when doing the vast majority of my coding , I 've actually found that more and more I 've been bookmarking blogs by developers more experienced and skilled than myself .
Moreso than most books , the blogs I keep bookmarked tend to have prefaces at the beginning of each article explaining exactly what programming obstacle the blogger had encountered , thus providing a concrete application for the code to follow in that article .</tokentext>
<sentencetext>Being self taught, one of the major revelations I had was that the more I tried to teach myself, the more I realized I knew just a FRACTION of what it took to become a good developer.
In the beginning when I thought I understood what i was doing, writing oop programs, when in fact I was writing procedural code with objects scattered around it.
Regular Expressions were (to me) among the arcane arts known by masters, engines were something to be licensed from those same masters, and I didn't even hear the words "design pattern" until I'd been trying to work professionally for over a year.
Many of the things I know today, I wouldn't have even known to ask/research/learn about back then, because I couldn't conceive of its existence.
Heck, I'll probably be saying that forever!
To quote a friend of mine:  "I cannot grasp the depth of my own ignorance.
"

However, while doing the 'self taught' thing, I have seen other threads like this recommending the staple books like the Petzold book for windows programming, the O'Reilly series, the Stroustrup book for C++, and the "Head First Design Patterns" book.
However since i still have google up when doing the vast majority of my coding, I've actually found that more and more I've been bookmarking blogs by developers more experienced and skilled than myself.
Moreso than most books, the blogs I keep bookmarked tend to have prefaces at the beginning of each article explaining exactly what programming obstacle the blogger had encountered, thus providing a concrete application for the code to follow in that article.
	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202884</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>buchner.johannes</author>
	<datestamp>1266612480000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p> <b>Programming Languages</b>: LL language parsing &amp; rules authoring.</p></div><p>I would say they miss the understanding of logic oriented programming languages (such as Prolog/Datalog) and functional programming languages (such as Haskell).</p><p>These approaches and ways of thinking can be very useful even if you program in a OOP language. Newer scripting languages also have a lot of features that cross the borders (such as lambda).</p></div>
	</htmltext>
<tokenext>Programming Languages : LL language parsing &amp; rules authoring.I would say they miss the understanding of logic oriented programming languages ( such as Prolog/Datalog ) and functional programming languages ( such as Haskell ) .These approaches and ways of thinking can be very useful even if you program in a OOP language .
Newer scripting languages also have a lot of features that cross the borders ( such as lambda ) .</tokentext>
<sentencetext> Programming Languages: LL language parsing &amp; rules authoring.I would say they miss the understanding of logic oriented programming languages (such as Prolog/Datalog) and functional programming languages (such as Haskell).These approaches and ways of thinking can be very useful even if you program in a OOP language.
Newer scripting languages also have a lot of features that cross the borders (such as lambda).
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203914</id>
	<title>Re:Even "Experts" Struggle with OOP</title>
	<author>Skal Tura</author>
	<datestamp>1266573060000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>OO is one of the most important tools in the bag. It's kind of like providing namespaces for functions if you have to oversimplify it. That alone, is such a powerfull notion makes OO justified in most tasks.<br>Ofc, a 50 liner, which does a single non-dynamic task would be a disadvantage to use OO.</p><p>OO excels in dynamic situations, and pursuing a huge array of features in the most minimal time.</p></htmltext>
<tokenext>OO is one of the most important tools in the bag .
It 's kind of like providing namespaces for functions if you have to oversimplify it .
That alone , is such a powerfull notion makes OO justified in most tasks.Ofc , a 50 liner , which does a single non-dynamic task would be a disadvantage to use OO.OO excels in dynamic situations , and pursuing a huge array of features in the most minimal time .</tokentext>
<sentencetext>OO is one of the most important tools in the bag.
It's kind of like providing namespaces for functions if you have to oversimplify it.
That alone, is such a powerfull notion makes OO justified in most tasks.Ofc, a 50 liner, which does a single non-dynamic task would be a disadvantage to use OO.OO excels in dynamic situations, and pursuing a huge array of features in the most minimal time.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201584</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202298</id>
	<title>would you recommend to fill in the gaps?</title>
	<author>Anonymous</author>
	<datestamp>1266609540000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Nothing.. keep doing what you are doing.. I'm a self taught programmer myself and fiddling with the code seems to bee and will always be the bet way do learn...<br>because you are not just learning "what to write" (copy&amp;paste like).. but you are learning "why to write".. what work and how it works.. and that will always give you a more deep understanding of the platforms and technologies..</p><p>Of course reading a bit about general concepts.. will help you generalize and will give you the tools to "abstractly" design and application.. but in the end it's always about implementation.. and that is what you need to know about.. And if it works.. well,fast and with out bugs.. who cares if is a "standard design" or just something you just cooked up.. if other is team dot understand.. then its them that need to get practical...</p><p>Not to seem to full of myself.. but if I compare with other guys in my company.. they may know all theory behind designs.. and may know a lot of buzz words.. but in the end.. I'm the one that does cleaner, simple working code.. and I'm the one, they all come to when they need to understand how the framework works or to make some kind of "tricky" code</p></htmltext>
<tokenext>Nothing.. keep doing what you are doing.. I 'm a self taught programmer myself and fiddling with the code seems to bee and will always be the bet way do learn...because you are not just learning " what to write " ( copy&amp;paste like ) .. but you are learning " why to write " .. what work and how it works.. and that will always give you a more deep understanding of the platforms and technologies..Of course reading a bit about general concepts.. will help you generalize and will give you the tools to " abstractly " design and application.. but in the end it 's always about implementation.. and that is what you need to know about.. And if it works.. well,fast and with out bugs.. who cares if is a " standard design " or just something you just cooked up.. if other is team dot understand.. then its them that need to get practical...Not to seem to full of myself.. but if I compare with other guys in my company.. they may know all theory behind designs.. and may know a lot of buzz words.. but in the end.. I 'm the one that does cleaner , simple working code.. and I 'm the one , they all come to when they need to understand how the framework works or to make some kind of " tricky " code</tokentext>
<sentencetext>Nothing.. keep doing what you are doing.. I'm a self taught programmer myself and fiddling with the code seems to bee and will always be the bet way do learn...because you are not just learning "what to write" (copy&amp;paste like).. but you are learning "why to write".. what work and how it works.. and that will always give you a more deep understanding of the platforms and technologies..Of course reading a bit about general concepts.. will help you generalize and will give you the tools to "abstractly" design and application.. but in the end it's always about implementation.. and that is what you need to know about.. And if it works.. well,fast and with out bugs.. who cares if is a "standard design" or just something you just cooked up.. if other is team dot understand.. then its them that need to get practical...Not to seem to full of myself.. but if I compare with other guys in my company.. they may know all theory behind designs.. and may know a lot of buzz words.. but in the end.. I'm the one that does cleaner, simple working code.. and I'm the one, they all come to when they need to understand how the framework works or to make some kind of "tricky" code</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199662</id>
	<title>Software engineering</title>
	<author>m.alessandrini</author>
	<datestamp>1266597060000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>Good software engineering practices (this is my personal experience). This is a problem when managing middle-to-large projects.</htmltext>
<tokenext>Good software engineering practices ( this is my personal experience ) .
This is a problem when managing middle-to-large projects .</tokentext>
<sentencetext>Good software engineering practices (this is my personal experience).
This is a problem when managing middle-to-large projects.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202214</id>
	<title>Depends on how long you've been at it</title>
	<author>bill\_kress</author>
	<datestamp>1266609000000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>The longer you work at it, the more you will be exposed to, but you'll learn a bit more over the first few years.  I'll list a few that come to mind.</p><p>Modeling--UML.  You really should know sequence diagrams, they rock.  Seriously.  When you need them, you NEED them.</p><p>O notation.  O1, On,<nobr> <wbr></nobr>...  Just helps you articulate some concepts that you intuitively know but might have trouble discussing with others.</p><p>Data Structures--what to the insides of a hash table or heap look like?</p><p>State Machines--They can replace threading in many scenarios, would you automatically know when and how to use one?</p><p>Low level crap--how are variables stored? how do references work? how do operating systems work?  Could you dive in and write a parser for a DSL if it was prudent?</p><p>There are also many areas that a self-taught person would have more in-depth knowledge then someone who decided to specialize in computer science after a year or two of college just due to his passion.</p><p>A lot of it, too, is simply communication.  If you take a class on Design Patterns, nearly everything they teach should be DAMN OBVIOUS to you, however if someone comes up and says that should use the Memento, Flyweight, Bridge or Builder pattern, would you know what they were saying?  When you need a pattern you should be able to derive it just through being a programmer, but how long does it take you to describe it without knowing the names?  Get a book on design patterns, by the way.  One on Refactoring wouldn't hurt either.</p></htmltext>
<tokenext>The longer you work at it , the more you will be exposed to , but you 'll learn a bit more over the first few years .
I 'll list a few that come to mind.Modeling--UML .
You really should know sequence diagrams , they rock .
Seriously. When you need them , you NEED them.O notation .
O1 , On , ... Just helps you articulate some concepts that you intuitively know but might have trouble discussing with others.Data Structures--what to the insides of a hash table or heap look like ? State Machines--They can replace threading in many scenarios , would you automatically know when and how to use one ? Low level crap--how are variables stored ?
how do references work ?
how do operating systems work ?
Could you dive in and write a parser for a DSL if it was prudent ? There are also many areas that a self-taught person would have more in-depth knowledge then someone who decided to specialize in computer science after a year or two of college just due to his passion.A lot of it , too , is simply communication .
If you take a class on Design Patterns , nearly everything they teach should be DAMN OBVIOUS to you , however if someone comes up and says that should use the Memento , Flyweight , Bridge or Builder pattern , would you know what they were saying ?
When you need a pattern you should be able to derive it just through being a programmer , but how long does it take you to describe it without knowing the names ?
Get a book on design patterns , by the way .
One on Refactoring would n't hurt either .</tokentext>
<sentencetext>The longer you work at it, the more you will be exposed to, but you'll learn a bit more over the first few years.
I'll list a few that come to mind.Modeling--UML.
You really should know sequence diagrams, they rock.
Seriously.  When you need them, you NEED them.O notation.
O1, On, ...  Just helps you articulate some concepts that you intuitively know but might have trouble discussing with others.Data Structures--what to the insides of a hash table or heap look like?State Machines--They can replace threading in many scenarios, would you automatically know when and how to use one?Low level crap--how are variables stored?
how do references work?
how do operating systems work?
Could you dive in and write a parser for a DSL if it was prudent?There are also many areas that a self-taught person would have more in-depth knowledge then someone who decided to specialize in computer science after a year or two of college just due to his passion.A lot of it, too, is simply communication.
If you take a class on Design Patterns, nearly everything they teach should be DAMN OBVIOUS to you, however if someone comes up and says that should use the Memento, Flyweight, Bridge or Builder pattern, would you know what they were saying?
When you need a pattern you should be able to derive it just through being a programmer, but how long does it take you to describe it without knowing the names?
Get a book on design patterns, by the way.
One on Refactoring wouldn't hurt either.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31204008</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>spinkham</author>
	<datestamp>1266573480000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I'd also add relational algebra and database normalization, but you've got a pretty good list there.</p></htmltext>
<tokenext>I 'd also add relational algebra and database normalization , but you 've got a pretty good list there .</tokentext>
<sentencetext>I'd also add relational algebra and database normalization, but you've got a pretty good list there.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203342</id>
	<title>My opinion</title>
	<author>stonecypher</author>
	<datestamp>1266571080000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Algorithms and datastructures are an enormous gap in most autodidacts' knowledge sets.  The NIST DADS is a great place to fight that, or alternatively an algorithms book like CLRS or Knuth 2.</p></htmltext>
<tokenext>Algorithms and datastructures are an enormous gap in most autodidacts ' knowledge sets .
The NIST DADS is a great place to fight that , or alternatively an algorithms book like CLRS or Knuth 2 .</tokentext>
<sentencetext>Algorithms and datastructures are an enormous gap in most autodidacts' knowledge sets.
The NIST DADS is a great place to fight that, or alternatively an algorithms book like CLRS or Knuth 2.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199904</id>
	<title>Algoritms</title>
	<author>Anonymous</author>
	<datestamp>1266598080000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Ability to estimate memory and computing power consumed by different algorithms. Or maybe you learned it too. But most self-taught programmers I met just learned syntax.</p></htmltext>
<tokenext>Ability to estimate memory and computing power consumed by different algorithms .
Or maybe you learned it too .
But most self-taught programmers I met just learned syntax .</tokentext>
<sentencetext>Ability to estimate memory and computing power consumed by different algorithms.
Or maybe you learned it too.
But most self-taught programmers I met just learned syntax.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199686</id>
	<title>All the important stuff</title>
	<author>Anonymous</author>
	<datestamp>1266597180000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>1</modscore>
	<htmltext><p>Transactions and threads. People tend to think of these as boring concepts and therefore don't learn all about them and how they work. An engineer who hasn't internalized these concepts is dangerous.</p></htmltext>
<tokenext>Transactions and threads .
People tend to think of these as boring concepts and therefore do n't learn all about them and how they work .
An engineer who has n't internalized these concepts is dangerous .</tokentext>
<sentencetext>Transactions and threads.
People tend to think of these as boring concepts and therefore don't learn all about them and how they work.
An engineer who hasn't internalized these concepts is dangerous.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31205906</id>
	<title>The best afterburner boost I ever had...</title>
	<author>Hurricane78</author>
	<datestamp>1266582600000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>...was learning Haskell! Even if you do it just for the sake of learning it. (Especially since that great new book came out last year.)</p><p>My code is on a whole different level now, since I have seen the Matrix.<nobr> <wbr></nobr>:)</p><p>Next step: QED, by Richard Feynman. (Should be a piece of cake now. ^^)</p></htmltext>
<tokenext>...was learning Haskell !
Even if you do it just for the sake of learning it .
( Especially since that great new book came out last year .
) My code is on a whole different level now , since I have seen the Matrix .
: ) Next step : QED , by Richard Feynman .
( Should be a piece of cake now .
^ ^ )</tokentext>
<sentencetext>...was learning Haskell!
Even if you do it just for the sake of learning it.
(Especially since that great new book came out last year.
)My code is on a whole different level now, since I have seen the Matrix.
:)Next step: QED, by Richard Feynman.
(Should be a piece of cake now.
^^)</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31204188</id>
	<title>Infrastructure knowledge</title>
	<author>realeyes</author>
	<datestamp>1266574320000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I have found that a lot of programmers don't understand the infrastructure of computers and networks.  They learn to read and write buffers without knowing what happens to the data next.  This has both performance and security implications.
<p>
From a performance perspective, a program that works well on a standalone system or even a LAN might be a dog over the web.  There is also the issue of scalability.  When you start pumping huge amounts of data into an app, it should not grind to a halt if the algorithms are as efficient as possible.  BTW, you can learn a lot about writing efficient code by working in assembler.
</p><p>
From a security perspective, you should not only be validating inputs and outputs based on the underlying infrastructure, but you should also provide the admins of your app with all the info you can to help them safely configure and maintain it.
</p><p>
Unfortunately, this is not limited to the self-taught.  I have not met anyone who took a course devoted to secure programming.  And the level of detail in various CS programs is all over the map.
</p><p>
Later . . .   Jim</p></htmltext>
<tokenext>I have found that a lot of programmers do n't understand the infrastructure of computers and networks .
They learn to read and write buffers without knowing what happens to the data next .
This has both performance and security implications .
From a performance perspective , a program that works well on a standalone system or even a LAN might be a dog over the web .
There is also the issue of scalability .
When you start pumping huge amounts of data into an app , it should not grind to a halt if the algorithms are as efficient as possible .
BTW , you can learn a lot about writing efficient code by working in assembler .
From a security perspective , you should not only be validating inputs and outputs based on the underlying infrastructure , but you should also provide the admins of your app with all the info you can to help them safely configure and maintain it .
Unfortunately , this is not limited to the self-taught .
I have not met anyone who took a course devoted to secure programming .
And the level of detail in various CS programs is all over the map .
Later .
. .
Jim</tokentext>
<sentencetext>I have found that a lot of programmers don't understand the infrastructure of computers and networks.
They learn to read and write buffers without knowing what happens to the data next.
This has both performance and security implications.
From a performance perspective, a program that works well on a standalone system or even a LAN might be a dog over the web.
There is also the issue of scalability.
When you start pumping huge amounts of data into an app, it should not grind to a halt if the algorithms are as efficient as possible.
BTW, you can learn a lot about writing efficient code by working in assembler.
From a security perspective, you should not only be validating inputs and outputs based on the underlying infrastructure, but you should also provide the admins of your app with all the info you can to help them safely configure and maintain it.
Unfortunately, this is not limited to the self-taught.
I have not met anyone who took a course devoted to secure programming.
And the level of detail in various CS programs is all over the map.
Later .
. .
Jim</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200542</id>
	<title>Re:Self-taught too.</title>
	<author>Anonymous</author>
	<datestamp>1266600840000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>&gt;&gt; There are lots of self made "experts" that claims the weirdest thing as hashing the password before sending it to the backend.

Haha, that reminds me of Yahoo mail a few years back.</htmltext>
<tokenext>&gt; &gt; There are lots of self made " experts " that claims the weirdest thing as hashing the password before sending it to the backend .
Haha , that reminds me of Yahoo mail a few years back .</tokentext>
<sentencetext>&gt;&gt; There are lots of self made "experts" that claims the weirdest thing as hashing the password before sending it to the backend.
Haha, that reminds me of Yahoo mail a few years back.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199688</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202740</id>
	<title>Here's what's missing.</title>
	<author>John Sokol</author>
	<datestamp>1266611880000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>You can learn the theory, semantics and grammar of programming, you can learn everything in the books, and in actuality be a better programmer.</p><p>But here is what you miss. A culture and a type of group think that the university pound in to the students.</p><p>This is one where they are taught to produce mounds of myopic code. They are taught not to ask questions and to be OK not understanding the bigger picture and how it all comes together.</p><p>At the same time more attention is given to every dam minute detail of a language and with trivial logic puzzle during the interviews that these guys get through better. While at the same time, produce mostly marginal bloating and inefficient code that will almost never take in to account future growth paths.</p><p>Being self taught myself,  I find it's getting increasingly harder to get in to corporate jobs because of this.</p><p>I have also run several startups and had many programmers working for me and have a hard time working with formally educated programmers unless they were self taught before they went to school.</p><p>This is again because with the self taught programmers I just have to share my goals and view, and they will plan with me.<br>With the "educated" ones, they just put out brittle code that lacks insight.</p><p>I guess it's like an English major vs. a best selling novelist who probably never needed to study English in college to get to where he is.</p></htmltext>
<tokenext>You can learn the theory , semantics and grammar of programming , you can learn everything in the books , and in actuality be a better programmer.But here is what you miss .
A culture and a type of group think that the university pound in to the students.This is one where they are taught to produce mounds of myopic code .
They are taught not to ask questions and to be OK not understanding the bigger picture and how it all comes together.At the same time more attention is given to every dam minute detail of a language and with trivial logic puzzle during the interviews that these guys get through better .
While at the same time , produce mostly marginal bloating and inefficient code that will almost never take in to account future growth paths.Being self taught myself , I find it 's getting increasingly harder to get in to corporate jobs because of this.I have also run several startups and had many programmers working for me and have a hard time working with formally educated programmers unless they were self taught before they went to school.This is again because with the self taught programmers I just have to share my goals and view , and they will plan with me.With the " educated " ones , they just put out brittle code that lacks insight.I guess it 's like an English major vs. a best selling novelist who probably never needed to study English in college to get to where he is .</tokentext>
<sentencetext>You can learn the theory, semantics and grammar of programming, you can learn everything in the books, and in actuality be a better programmer.But here is what you miss.
A culture and a type of group think that the university pound in to the students.This is one where they are taught to produce mounds of myopic code.
They are taught not to ask questions and to be OK not understanding the bigger picture and how it all comes together.At the same time more attention is given to every dam minute detail of a language and with trivial logic puzzle during the interviews that these guys get through better.
While at the same time, produce mostly marginal bloating and inefficient code that will almost never take in to account future growth paths.Being self taught myself,  I find it's getting increasingly harder to get in to corporate jobs because of this.I have also run several startups and had many programmers working for me and have a hard time working with formally educated programmers unless they were self taught before they went to school.This is again because with the self taught programmers I just have to share my goals and view, and they will plan with me.With the "educated" ones, they just put out brittle code that lacks insight.I guess it's like an English major vs. a best selling novelist who probably never needed to study English in college to get to where he is.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31205310</id>
	<title>There are some general differences</title>
	<author>wienerschnizzel</author>
	<datestamp>1266579120000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Each individual is different and I've met some great self-taught programmers as well as poor programmers with with CS degree. <br> <br>

There are some general rules of thumbs though:
<br> <br>
 - a lot of the self-taught coders are actually college drop-outs that might be technically good but have a poor work ethic <br>
 - there are self-taught programmers with a degree from a different field (Electrical engineering for instance). Those can generally do a good job as coders if they spend enough time researching the new (computer science) field tackling coding problems <br>
 - open source participation is probably the best way to distinguish a good self-taught coder from a bad one - if a person demonstrably does a lot of work in OS projects he/she can easily become the most resourceful, enthusiastic and helpful colleague</htmltext>
<tokenext>Each individual is different and I 've met some great self-taught programmers as well as poor programmers with with CS degree .
There are some general rules of thumbs though : - a lot of the self-taught coders are actually college drop-outs that might be technically good but have a poor work ethic - there are self-taught programmers with a degree from a different field ( Electrical engineering for instance ) .
Those can generally do a good job as coders if they spend enough time researching the new ( computer science ) field tackling coding problems - open source participation is probably the best way to distinguish a good self-taught coder from a bad one - if a person demonstrably does a lot of work in OS projects he/she can easily become the most resourceful , enthusiastic and helpful colleague</tokentext>
<sentencetext>Each individual is different and I've met some great self-taught programmers as well as poor programmers with with CS degree.
There are some general rules of thumbs though:
 
 - a lot of the self-taught coders are actually college drop-outs that might be technically good but have a poor work ethic 
 - there are self-taught programmers with a degree from a different field (Electrical engineering for instance).
Those can generally do a good job as coders if they spend enough time researching the new (computer science) field tackling coding problems 
 - open source participation is probably the best way to distinguish a good self-taught coder from a bad one - if a person demonstrably does a lot of work in OS projects he/she can easily become the most resourceful, enthusiastic and helpful colleague</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31205870</id>
	<title>University is about learning how to learn</title>
	<author>vtavares</author>
	<datestamp>1266582360000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>One thing I haven't seen mentioned is what the whole university experience is supposed to be fundamentally about learning how to learn. Yes, in Computer Science/Software Engineering you will get a broad brush of skills and training, from computing concepts, mathematics, and sciences. But you will also be exposed to other knowledge domains at a high level - economics, business, psychology, philosophy, languages - no, not programming but spoken, etc.</p><p>Some of the best programmers I have ever worked with had little to no real training in daily programming skills. Instead, they had degrees in other fields that allowed them to be free thinkers. This helps with solving complex problems, thinking "outside the box" and having a broad experience in things other than programming language details. Anyone can read books on advanced C++ techniques and other "learn how to program in 21 days" types of books and do a decent job at coding. However, I want people who have been through a difficult university program and not only survived, but excelled and had a broad experience. Sure, they might take a bit longer to get up to speed on the "design patterns" and "agile programming" methodology du jour, but they will probably be more likely to excel in a challenging, free thinking, problem solving work environment. Sure, some exceptional, self-taught people can also be amazing, but that's usually the exception.</p><p>If you just need coders that write php code to spec, stick to self-taught or community college grads - they are cheaper.</p></htmltext>
<tokenext>One thing I have n't seen mentioned is what the whole university experience is supposed to be fundamentally about learning how to learn .
Yes , in Computer Science/Software Engineering you will get a broad brush of skills and training , from computing concepts , mathematics , and sciences .
But you will also be exposed to other knowledge domains at a high level - economics , business , psychology , philosophy , languages - no , not programming but spoken , etc.Some of the best programmers I have ever worked with had little to no real training in daily programming skills .
Instead , they had degrees in other fields that allowed them to be free thinkers .
This helps with solving complex problems , thinking " outside the box " and having a broad experience in things other than programming language details .
Anyone can read books on advanced C + + techniques and other " learn how to program in 21 days " types of books and do a decent job at coding .
However , I want people who have been through a difficult university program and not only survived , but excelled and had a broad experience .
Sure , they might take a bit longer to get up to speed on the " design patterns " and " agile programming " methodology du jour , but they will probably be more likely to excel in a challenging , free thinking , problem solving work environment .
Sure , some exceptional , self-taught people can also be amazing , but that 's usually the exception.If you just need coders that write php code to spec , stick to self-taught or community college grads - they are cheaper .</tokentext>
<sentencetext>One thing I haven't seen mentioned is what the whole university experience is supposed to be fundamentally about learning how to learn.
Yes, in Computer Science/Software Engineering you will get a broad brush of skills and training, from computing concepts, mathematics, and sciences.
But you will also be exposed to other knowledge domains at a high level - economics, business, psychology, philosophy, languages - no, not programming but spoken, etc.Some of the best programmers I have ever worked with had little to no real training in daily programming skills.
Instead, they had degrees in other fields that allowed them to be free thinkers.
This helps with solving complex problems, thinking "outside the box" and having a broad experience in things other than programming language details.
Anyone can read books on advanced C++ techniques and other "learn how to program in 21 days" types of books and do a decent job at coding.
However, I want people who have been through a difficult university program and not only survived, but excelled and had a broad experience.
Sure, they might take a bit longer to get up to speed on the "design patterns" and "agile programming" methodology du jour, but they will probably be more likely to excel in a challenging, free thinking, problem solving work environment.
Sure, some exceptional, self-taught people can also be amazing, but that's usually the exception.If you just need coders that write php code to spec, stick to self-taught or community college grads - they are cheaper.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31208634</id>
	<title>Re:Passion</title>
	<author>macs4all</author>
	<datestamp>1266657780000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>Self-taught = passionate = "talent" not teachable in class I know who I'd rather hire</p></div><p>Are you hiring (seriously!)?</p></div>
	</htmltext>
<tokenext>Self-taught = passionate = " talent " not teachable in class I know who I 'd rather hireAre you hiring ( seriously !
) ?</tokentext>
<sentencetext>Self-taught = passionate = "talent" not teachable in class I know who I'd rather hireAre you hiring (seriously!
)?
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200160</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203090</id>
	<title>Complexity</title>
	<author>renoX</author>
	<datestamp>1266570120000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>One interesting thing to learn is about algorithm which are O(n), O(n2), etc.<br>It's not difficult and it can help optimising a program..</p><p>Also the way to proof that the program is correct (there's a introduction about it in programming's pearls*), it's not used often but it can be very useful for 'tricky' algorithms.</p><p>*Funnily the sort program with the proofs has still bugs: it computes the middle of a range with middle:=(x + y)/2 which can overflow!!</p></htmltext>
<tokenext>One interesting thing to learn is about algorithm which are O ( n ) , O ( n2 ) , etc.It 's not difficult and it can help optimising a program..Also the way to proof that the program is correct ( there 's a introduction about it in programming 's pearls * ) , it 's not used often but it can be very useful for 'tricky ' algorithms .
* Funnily the sort program with the proofs has still bugs : it computes the middle of a range with middle : = ( x + y ) /2 which can overflow !
!</tokentext>
<sentencetext>One interesting thing to learn is about algorithm which are O(n), O(n2), etc.It's not difficult and it can help optimising a program..Also the way to proof that the program is correct (there's a introduction about it in programming's pearls*), it's not used often but it can be very useful for 'tricky' algorithms.
*Funnily the sort program with the proofs has still bugs: it computes the middle of a range with middle:=(x + y)/2 which can overflow!
!</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200576</id>
	<title>Grammar</title>
	<author>michaelmalak</author>
	<datestamp>1266600960000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>By getting a college degree, you are ensuring a literacy level of at least what would have been a seventh-grade education 30 years ago.  With just a high school diploma, one's literacy level would only be at about a third grade level 30 years ago.<p>Computer programming is of little value without the ability to communicate.</p><p>I have to hire college graduates to change diapers at the school I run -- to ensure that when they do speak to the children, they do so with correct grammar.</p></htmltext>
<tokenext>By getting a college degree , you are ensuring a literacy level of at least what would have been a seventh-grade education 30 years ago .
With just a high school diploma , one 's literacy level would only be at about a third grade level 30 years ago.Computer programming is of little value without the ability to communicate.I have to hire college graduates to change diapers at the school I run -- to ensure that when they do speak to the children , they do so with correct grammar .</tokentext>
<sentencetext>By getting a college degree, you are ensuring a literacy level of at least what would have been a seventh-grade education 30 years ago.
With just a high school diploma, one's literacy level would only be at about a third grade level 30 years ago.Computer programming is of little value without the ability to communicate.I have to hire college graduates to change diapers at the school I run -- to ensure that when they do speak to the children, they do so with correct grammar.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199558</id>
	<title>A job</title>
	<author>Anonymous</author>
	<datestamp>1266596520000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I've learned more in the right job than from any book or course.</p></htmltext>
<tokenext>I 've learned more in the right job than from any book or course .</tokentext>
<sentencetext>I've learned more in the right job than from any book or course.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200460</id>
	<title>Lack of Broadness</title>
	<author>Sloppy</author>
	<datestamp>1266600480000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>IMHO it's not going to be <em>specific</em> gap; the gap is going to be quantitative.  Formally taught programmers will have fewer of them, because they're "forced" to work on stuff that doesn't interest them or otherwise wouldn't ever come up in their projects (or doesn't <em>appear</em> to them, to come up in their projects).  You can be self-taught and have a <em>shitload</em> of professional experience, and yet that experience can be very narrow, whereas a CS graduate is going to have most of the bases covered.</p><p>So it's not so much a matter of self-taught people not knowing design patterns or algorithm complexity analysis; it's that they're just generally less likely to know them, and even less likely to know <em>both.</em>  That's why I think a lot of peoples' suggestions here will ring true at first, except that for any of them you're also going to realize there are a lot of counter-examples, where self-taught programmer x actually <em>does</em> know about complexity analysis. But keep adding and adding to the list, and you'll see that the CS guys know almost <em>all</em> of it, and the self-taught ones know less of it.  It's not this item or this item; it's the <em>count.</em></p></htmltext>
<tokenext>IMHO it 's not going to be specific gap ; the gap is going to be quantitative .
Formally taught programmers will have fewer of them , because they 're " forced " to work on stuff that does n't interest them or otherwise would n't ever come up in their projects ( or does n't appear to them , to come up in their projects ) .
You can be self-taught and have a shitload of professional experience , and yet that experience can be very narrow , whereas a CS graduate is going to have most of the bases covered.So it 's not so much a matter of self-taught people not knowing design patterns or algorithm complexity analysis ; it 's that they 're just generally less likely to know them , and even less likely to know both .
That 's why I think a lot of peoples ' suggestions here will ring true at first , except that for any of them you 're also going to realize there are a lot of counter-examples , where self-taught programmer x actually does know about complexity analysis .
But keep adding and adding to the list , and you 'll see that the CS guys know almost all of it , and the self-taught ones know less of it .
It 's not this item or this item ; it 's the count .</tokentext>
<sentencetext>IMHO it's not going to be specific gap; the gap is going to be quantitative.
Formally taught programmers will have fewer of them, because they're "forced" to work on stuff that doesn't interest them or otherwise wouldn't ever come up in their projects (or doesn't appear to them, to come up in their projects).
You can be self-taught and have a shitload of professional experience, and yet that experience can be very narrow, whereas a CS graduate is going to have most of the bases covered.So it's not so much a matter of self-taught people not knowing design patterns or algorithm complexity analysis; it's that they're just generally less likely to know them, and even less likely to know both.
That's why I think a lot of peoples' suggestions here will ring true at first, except that for any of them you're also going to realize there are a lot of counter-examples, where self-taught programmer x actually does know about complexity analysis.
But keep adding and adding to the list, and you'll see that the CS guys know almost all of it, and the self-taught ones know less of it.
It's not this item or this item; it's the count.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203396</id>
	<title>...the knowledge of how useless a CS degree is...</title>
	<author>AndyGasman</author>
	<datestamp>1266571260000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I've found most formal training fairly useless.

This is also what I've heard recounted by most of my community and profession peers.  I think this is the same whether it is CS, ElecEng (software) or my own personal choice, industrial design.  This is from a sample of several hundred software developers, and web developers in the UK, USA and Australia.  It has also been my experience as an developers being responsible for looking after new graduate employees.

There is real value in learning how to learn.  An in this sense post-grad courses can be of more practical use I'd say, though they still have potential to be as useless.

I realise this is a broad brush stoke, and I would confess my own degree has given me useful skills in team working, usability and an understanding of what a waste of time formal education is, well 95\% of it anyway.</htmltext>
<tokenext>I 've found most formal training fairly useless .
This is also what I 've heard recounted by most of my community and profession peers .
I think this is the same whether it is CS , ElecEng ( software ) or my own personal choice , industrial design .
This is from a sample of several hundred software developers , and web developers in the UK , USA and Australia .
It has also been my experience as an developers being responsible for looking after new graduate employees .
There is real value in learning how to learn .
An in this sense post-grad courses can be of more practical use I 'd say , though they still have potential to be as useless .
I realise this is a broad brush stoke , and I would confess my own degree has given me useful skills in team working , usability and an understanding of what a waste of time formal education is , well 95 \ % of it anyway .</tokentext>
<sentencetext>I've found most formal training fairly useless.
This is also what I've heard recounted by most of my community and profession peers.
I think this is the same whether it is CS, ElecEng (software) or my own personal choice, industrial design.
This is from a sample of several hundred software developers, and web developers in the UK, USA and Australia.
It has also been my experience as an developers being responsible for looking after new graduate employees.
There is real value in learning how to learn.
An in this sense post-grad courses can be of more practical use I'd say, though they still have potential to be as useless.
I realise this is a broad brush stoke, and I would confess my own degree has given me useful skills in team working, usability and an understanding of what a waste of time formal education is, well 95\% of it anyway.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199842</id>
	<title>Use Google to fill the gap</title>
	<author>somejeff</author>
	<datestamp>1266597840000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>IMO, those who are not self-taught (and spent months in some "History of the Abacus" class) can search the Interweb for code samples and tinker around.

One day, they'll fill the gap and catch up to us.</htmltext>
<tokenext>IMO , those who are not self-taught ( and spent months in some " History of the Abacus " class ) can search the Interweb for code samples and tinker around .
One day , they 'll fill the gap and catch up to us .</tokentext>
<sentencetext>IMO, those who are not self-taught (and spent months in some "History of the Abacus" class) can search the Interweb for code samples and tinker around.
One day, they'll fill the gap and catch up to us.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31206994</id>
	<title>not so avoidable!</title>
	<author>r00t</author>
	<datestamp>1266591780000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>one example would be to display a table with a drop down for selecting colors, fetching the color list from the database for every row even if it's the same for all of them</p></div><p>Programmers often work in teams on large projects. They may even work for different employers, supplying libraries to a 3rd party who puts them together.</p><p>Programmer X does an array index operation to get the color name. He's assuming that this is really fast.</p><p>Programmer Y overloads operator[] so that he can internationalize the code. In all the usage examples he's ever seen, nobody looks up color names in a loop. He's assuming that this isn't done.</p></div>
	</htmltext>
<tokenext>one example would be to display a table with a drop down for selecting colors , fetching the color list from the database for every row even if it 's the same for all of themProgrammers often work in teams on large projects .
They may even work for different employers , supplying libraries to a 3rd party who puts them together.Programmer X does an array index operation to get the color name .
He 's assuming that this is really fast.Programmer Y overloads operator [ ] so that he can internationalize the code .
In all the usage examples he 's ever seen , nobody looks up color names in a loop .
He 's assuming that this is n't done .</tokentext>
<sentencetext>one example would be to display a table with a drop down for selecting colors, fetching the color list from the database for every row even if it's the same for all of themProgrammers often work in teams on large projects.
They may even work for different employers, supplying libraries to a 3rd party who puts them together.Programmer X does an array index operation to get the color name.
He's assuming that this is really fast.Programmer Y overloads operator[] so that he can internationalize the code.
In all the usage examples he's ever seen, nobody looks up color names in a loop.
He's assuming that this isn't done.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199688</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31216154</id>
	<title>SICP</title>
	<author>jknapka</author>
	<datestamp>1266688260000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Read "Structure and Interpretation of Computer Programs" by Abelson and Sussman.  Do as many of the exercises as you can make time for.  You will end up a better programmer than most CS graduates.
<p>
That book does two things that I found revelatory:
</p><p>
1) Exposes you to functional programming and important features thereof (such as  referential transparency) from the very beginning.
</p><p>
2) Starts with a very high-level, functional model of computation (the Scheme language, which is essentially lambda calculus), and proceeds toward increasingly low-level models of computation, culminating in a Scheme evaluator based on a traditional stack machine.  Many programming books tell that story in reverse, starting with memory and registers and instruction sets, and then explaining how high-level language constructs map onto those low-level concepts.  By starting at the functional level and elaborating increasingly detailed models of physical computation, Abelson and Sussman drive home the point that computation is an abstraction that can be implemented, and thought about,  in lots of different ways.
</p><p>
It really is a mind-blowing experience.  I read it after 15 years as a professional programmer in languages from assembly through C to Lisp and Prolog, and I learned A LOT from it.</p></htmltext>
<tokenext>Read " Structure and Interpretation of Computer Programs " by Abelson and Sussman .
Do as many of the exercises as you can make time for .
You will end up a better programmer than most CS graduates .
That book does two things that I found revelatory : 1 ) Exposes you to functional programming and important features thereof ( such as referential transparency ) from the very beginning .
2 ) Starts with a very high-level , functional model of computation ( the Scheme language , which is essentially lambda calculus ) , and proceeds toward increasingly low-level models of computation , culminating in a Scheme evaluator based on a traditional stack machine .
Many programming books tell that story in reverse , starting with memory and registers and instruction sets , and then explaining how high-level language constructs map onto those low-level concepts .
By starting at the functional level and elaborating increasingly detailed models of physical computation , Abelson and Sussman drive home the point that computation is an abstraction that can be implemented , and thought about , in lots of different ways .
It really is a mind-blowing experience .
I read it after 15 years as a professional programmer in languages from assembly through C to Lisp and Prolog , and I learned A LOT from it .</tokentext>
<sentencetext>Read "Structure and Interpretation of Computer Programs" by Abelson and Sussman.
Do as many of the exercises as you can make time for.
You will end up a better programmer than most CS graduates.
That book does two things that I found revelatory:

1) Exposes you to functional programming and important features thereof (such as  referential transparency) from the very beginning.
2) Starts with a very high-level, functional model of computation (the Scheme language, which is essentially lambda calculus), and proceeds toward increasingly low-level models of computation, culminating in a Scheme evaluator based on a traditional stack machine.
Many programming books tell that story in reverse, starting with memory and registers and instruction sets, and then explaining how high-level language constructs map onto those low-level concepts.
By starting at the functional level and elaborating increasingly detailed models of physical computation, Abelson and Sussman drive home the point that computation is an abstraction that can be implemented, and thought about,  in lots of different ways.
It really is a mind-blowing experience.
I read it after 15 years as a professional programmer in languages from assembly through C to Lisp and Prolog, and I learned A LOT from it.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199990</id>
	<title>Great question! - a list from my experience</title>
	<author>david.emery</author>
	<datestamp>1266598440000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I'm about 3/4 self-taught, I had some CS courses in college (before there was even a CS minor in the school) and a couple of grad school courses (which I can't say I got all that much from.)</p><p>But here's my list, based on what I've experienced over the last 30 years:</p><p>
&nbsp; &nbsp; &nbsp; analysis of algorithms, "Big O" and similar things.  If you've read a basic data structures book, you -might have- seen this stuff.  But it's really important theory to understand.  I'd rate this as the #1 gap; people who don't have this knowledge have a real hard time reasoning about or discussing performance, etc.</p><p>
&nbsp; &nbsp; AI - not an interest of mine, so I've never bothered to learn it.  But that's a big hole in my own knowledge.  That includes knowledge representation, reasoning systems, etc.</p><p>
&nbsp; &nbsp; multiple programming paradigms - In this case I'm "OK", I've learned and applied several different programming languages (most of which are not popular/politically correct these days...)  I've said I'd never hire a mono-lingual programmer, and that's because learning different languages has given me other ways to look at problems.  (See <a href="http://en.wikipedia.org/wiki/Sapir-whorf" title="wikipedia.org">http://en.wikipedia.org/wiki/Sapir-whorf</a> [wikipedia.org] - which applies to programming languages as much as natural languages!)</p><p>
&nbsp; &nbsp; numeric analysis - That's one of 2 post-grad courses I took where I actually learned a lot, and it seems that numeric analysis is somewhat of a dying art.  But a lot of what we do is still 'calculating', so this is important to know.</p><p>
&nbsp; &nbsp; concurrency - Here I'm personally in good shape because it is an interest, and I've done a lot of work in Ada which provides a very strong concurrent programming model.  But things like race conditions, deadlock, consensus algorithms, etc. are growing in importance due to multi-core CPUs.  Nancy Lynch's "Distributed Algorithms" is The Book to read here, too bad it's so expensive  (http://www.amazon.com/Distributed-Algorithms-Kaufmann-Management-Systems/dp/1558603484)</p><p>
&nbsp; &nbsp; compiler theory - it's worth knowing how language processing tools work, and with compiler theory (parsers, etc), I'd add knowledge of machine languages.  If you ever have to go down to assembly language to find a compiler optimization bug (something I've had to so several times - ain't fun), you MUST know this stuff.</p><p>
&nbsp; &nbsp; optimization/operations research mathematics - I'm not sure how much this gets taught in CS departments, but I was fortunate enough to get -2- Operations Research courses as a math major (at 2 different schools...)  Understanding linear programming, integer programming (things change when you can only deal in whole numbers), PERT/CPM, etc, has proven to be valuable for both hard-core programming and for systems design (and even project management.)    I'd also add graph theory to this list, a lot of problems I've worked on are graph problems (they show up in compiler construction, too...)</p><p>
&nbsp; &nbsp; I've learned -a lot- just by reading other people's code, too.  Remember, a program is written once, but read many times during its lifetime.  Reading code gives you both an appreciation for how others attack a problem, and the need to make your own code more understandable.  This is where the Open Source movement has been a Godsend.  (I'll note in passing the Ada community was very good about sharing source code back in the '80s when this wasn't as popular as it is today.)</p><p>Finally, a "meta-comment":  Although my formal education in CS itself was weak, I've invested a lot in learning on my own.  I'm sure my professors would argue they taught me how to learn, and there's some truth to that.  But not everyone will snuggle up to a textbook on graph theory on a snowy winter night<nobr> <wbr></nobr>:-)</p></htmltext>
<tokenext>I 'm about 3/4 self-taught , I had some CS courses in college ( before there was even a CS minor in the school ) and a couple of grad school courses ( which I ca n't say I got all that much from .
) But here 's my list , based on what I 've experienced over the last 30 years :       analysis of algorithms , " Big O " and similar things .
If you 've read a basic data structures book , you -might have- seen this stuff .
But it 's really important theory to understand .
I 'd rate this as the # 1 gap ; people who do n't have this knowledge have a real hard time reasoning about or discussing performance , etc .
    AI - not an interest of mine , so I 've never bothered to learn it .
But that 's a big hole in my own knowledge .
That includes knowledge representation , reasoning systems , etc .
    multiple programming paradigms - In this case I 'm " OK " , I 've learned and applied several different programming languages ( most of which are not popular/politically correct these days... ) I 've said I 'd never hire a mono-lingual programmer , and that 's because learning different languages has given me other ways to look at problems .
( See http : //en.wikipedia.org/wiki/Sapir-whorf [ wikipedia.org ] - which applies to programming languages as much as natural languages !
)     numeric analysis - That 's one of 2 post-grad courses I took where I actually learned a lot , and it seems that numeric analysis is somewhat of a dying art .
But a lot of what we do is still 'calculating ' , so this is important to know .
    concurrency - Here I 'm personally in good shape because it is an interest , and I 've done a lot of work in Ada which provides a very strong concurrent programming model .
But things like race conditions , deadlock , consensus algorithms , etc .
are growing in importance due to multi-core CPUs .
Nancy Lynch 's " Distributed Algorithms " is The Book to read here , too bad it 's so expensive ( http : //www.amazon.com/Distributed-Algorithms-Kaufmann-Management-Systems/dp/1558603484 )     compiler theory - it 's worth knowing how language processing tools work , and with compiler theory ( parsers , etc ) , I 'd add knowledge of machine languages .
If you ever have to go down to assembly language to find a compiler optimization bug ( something I 've had to so several times - ai n't fun ) , you MUST know this stuff .
    optimization/operations research mathematics - I 'm not sure how much this gets taught in CS departments , but I was fortunate enough to get -2- Operations Research courses as a math major ( at 2 different schools... ) Understanding linear programming , integer programming ( things change when you can only deal in whole numbers ) , PERT/CPM , etc , has proven to be valuable for both hard-core programming and for systems design ( and even project management .
) I 'd also add graph theory to this list , a lot of problems I 've worked on are graph problems ( they show up in compiler construction , too... )     I 've learned -a lot- just by reading other people 's code , too .
Remember , a program is written once , but read many times during its lifetime .
Reading code gives you both an appreciation for how others attack a problem , and the need to make your own code more understandable .
This is where the Open Source movement has been a Godsend .
( I 'll note in passing the Ada community was very good about sharing source code back in the '80s when this was n't as popular as it is today .
) Finally , a " meta-comment " : Although my formal education in CS itself was weak , I 've invested a lot in learning on my own .
I 'm sure my professors would argue they taught me how to learn , and there 's some truth to that .
But not everyone will snuggle up to a textbook on graph theory on a snowy winter night : - )</tokentext>
<sentencetext>I'm about 3/4 self-taught, I had some CS courses in college (before there was even a CS minor in the school) and a couple of grad school courses (which I can't say I got all that much from.
)But here's my list, based on what I've experienced over the last 30 years:
      analysis of algorithms, "Big O" and similar things.
If you've read a basic data structures book, you -might have- seen this stuff.
But it's really important theory to understand.
I'd rate this as the #1 gap; people who don't have this knowledge have a real hard time reasoning about or discussing performance, etc.
    AI - not an interest of mine, so I've never bothered to learn it.
But that's a big hole in my own knowledge.
That includes knowledge representation, reasoning systems, etc.
    multiple programming paradigms - In this case I'm "OK", I've learned and applied several different programming languages (most of which are not popular/politically correct these days...)  I've said I'd never hire a mono-lingual programmer, and that's because learning different languages has given me other ways to look at problems.
(See http://en.wikipedia.org/wiki/Sapir-whorf [wikipedia.org] - which applies to programming languages as much as natural languages!
)
    numeric analysis - That's one of 2 post-grad courses I took where I actually learned a lot, and it seems that numeric analysis is somewhat of a dying art.
But a lot of what we do is still 'calculating', so this is important to know.
    concurrency - Here I'm personally in good shape because it is an interest, and I've done a lot of work in Ada which provides a very strong concurrent programming model.
But things like race conditions, deadlock, consensus algorithms, etc.
are growing in importance due to multi-core CPUs.
Nancy Lynch's "Distributed Algorithms" is The Book to read here, too bad it's so expensive  (http://www.amazon.com/Distributed-Algorithms-Kaufmann-Management-Systems/dp/1558603484)
    compiler theory - it's worth knowing how language processing tools work, and with compiler theory (parsers, etc), I'd add knowledge of machine languages.
If you ever have to go down to assembly language to find a compiler optimization bug (something I've had to so several times - ain't fun), you MUST know this stuff.
    optimization/operations research mathematics - I'm not sure how much this gets taught in CS departments, but I was fortunate enough to get -2- Operations Research courses as a math major (at 2 different schools...)  Understanding linear programming, integer programming (things change when you can only deal in whole numbers), PERT/CPM, etc, has proven to be valuable for both hard-core programming and for systems design (and even project management.
)    I'd also add graph theory to this list, a lot of problems I've worked on are graph problems (they show up in compiler construction, too...)
    I've learned -a lot- just by reading other people's code, too.
Remember, a program is written once, but read many times during its lifetime.
Reading code gives you both an appreciation for how others attack a problem, and the need to make your own code more understandable.
This is where the Open Source movement has been a Godsend.
(I'll note in passing the Ada community was very good about sharing source code back in the '80s when this wasn't as popular as it is today.
)Finally, a "meta-comment":  Although my formal education in CS itself was weak, I've invested a lot in learning on my own.
I'm sure my professors would argue they taught me how to learn, and there's some truth to that.
But not everyone will snuggle up to a textbook on graph theory on a snowy winter night :-)</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203200</id>
	<title>That etc. is Huge</title>
	<author>DannyO152</author>
	<datestamp>1266570540000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Functional Programming, unless your etc. did include Lisp/Scheme or OCaml or Haskell.</p><p>Some assembly wouldn't hurt.</p><p>Why? Different ways of thinking about solutions and it will feed back positively into what you do with the imperative C-like languages you did list.</p></htmltext>
<tokenext>Functional Programming , unless your etc .
did include Lisp/Scheme or OCaml or Haskell.Some assembly would n't hurt.Why ?
Different ways of thinking about solutions and it will feed back positively into what you do with the imperative C-like languages you did list .</tokentext>
<sentencetext>Functional Programming, unless your etc.
did include Lisp/Scheme or OCaml or Haskell.Some assembly wouldn't hurt.Why?
Different ways of thinking about solutions and it will feed back positively into what you do with the imperative C-like languages you did list.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203054</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>Anonymous</author>
	<datestamp>1266570060000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>And all the other crap you'll never use after college.</p></htmltext>
<tokenext>And all the other crap you 'll never use after college .</tokentext>
<sentencetext>And all the other crap you'll never use after college.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203210</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>plcurechax</author>
	<datestamp>1266570660000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I think the biggest difference <b>can</b> be in the motivations. Many of the self-taught programmers I've met or worked with their legacy (code), enjoy what they are doing. The dot-com boom increased the numbers of both CS post-secondary enrollment as well as the "self-professed" programmers who were merely motivated by the money. The "self-professed" tend to be more transparent about it, so are quicker to be weeded out, I suspect.</p><p><i>coming out of school often still have a horrible worth ethic</i></p><p>It's opinion, but I conjecture that it may have more to do with maturity than knowledge or experience. For many it isn't until they are out of college before they have to make their own decisions, and so are facing a large amount of growing up at the same time.</p><p>Both can be good, both can be lame.</p></htmltext>
<tokenext>I think the biggest difference can be in the motivations .
Many of the self-taught programmers I 've met or worked with their legacy ( code ) , enjoy what they are doing .
The dot-com boom increased the numbers of both CS post-secondary enrollment as well as the " self-professed " programmers who were merely motivated by the money .
The " self-professed " tend to be more transparent about it , so are quicker to be weeded out , I suspect.coming out of school often still have a horrible worth ethicIt 's opinion , but I conjecture that it may have more to do with maturity than knowledge or experience .
For many it is n't until they are out of college before they have to make their own decisions , and so are facing a large amount of growing up at the same time.Both can be good , both can be lame .</tokentext>
<sentencetext>I think the biggest difference can be in the motivations.
Many of the self-taught programmers I've met or worked with their legacy (code), enjoy what they are doing.
The dot-com boom increased the numbers of both CS post-secondary enrollment as well as the "self-professed" programmers who were merely motivated by the money.
The "self-professed" tend to be more transparent about it, so are quicker to be weeded out, I suspect.coming out of school often still have a horrible worth ethicIt's opinion, but I conjecture that it may have more to do with maturity than knowledge or experience.
For many it isn't until they are out of college before they have to make their own decisions, and so are facing a large amount of growing up at the same time.Both can be good, both can be lame.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200448</id>
	<title>Algorithm Analysis</title>
	<author>zimage</author>
	<datestamp>1266600480000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>One of the biggest ones I've seen is that self-taught programmers tend to not think about algorithm efficiency.  Learn how to determine the big-O of your functions and learn how to code more scalable algorithms.</p><p><a href="http://en.wikipedia.org/wiki/Algorithm\_analysis" title="wikipedia.org">http://en.wikipedia.org/wiki/Algorithm\_analysis</a> [wikipedia.org]<br><a href="http://en.wikipedia.org/wiki/Big\_O\_notation" title="wikipedia.org">http://en.wikipedia.org/wiki/Big\_O\_notation</a> [wikipedia.org]</p></htmltext>
<tokenext>One of the biggest ones I 've seen is that self-taught programmers tend to not think about algorithm efficiency .
Learn how to determine the big-O of your functions and learn how to code more scalable algorithms.http : //en.wikipedia.org/wiki/Algorithm \ _analysis [ wikipedia.org ] http : //en.wikipedia.org/wiki/Big \ _O \ _notation [ wikipedia.org ]</tokentext>
<sentencetext>One of the biggest ones I've seen is that self-taught programmers tend to not think about algorithm efficiency.
Learn how to determine the big-O of your functions and learn how to code more scalable algorithms.http://en.wikipedia.org/wiki/Algorithm\_analysis [wikipedia.org]http://en.wikipedia.org/wiki/Big\_O\_notation [wikipedia.org]</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31206638</id>
	<title>Strong cryptography.</title>
	<author>DamnStupidElf</author>
	<datestamp>1266588060000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>It seems like too many people think encryption is only about scrambling data until it looks hard to recover.  This isn't just a knock against self taught programmers, but I do tend to see it slightly more often in self taught individuals (including myself; when I was a kid I thought repeatedly XORing a password with plaintext was a great idea until I figured out how to automatically recover the passphrase from the ciphertext with statistical analysis a few years later). Anyone who's looked even slightly deeper knows that cryptography is seriously hard and involves knowing advanced mathematics and learning about every advanced published attack before attempting to design a cipher.  Even if you pick trusted cryptosystems, there are timing attacks, watermarking attacks, man in the middle attacks, side channel attacks, and any number of other security problems that have to be addressed in the system using the cryptographic primitives.  General security is hard, but secure cryptography is arguably even harder.  You might think that a general programmer won't run into problems involving cryptography very often, but how many programs or web sites need to manage users and permissions?  Store passwords that aren't vulnerable to rainbow tables?  Transfer data over the Internet to another trusted host or user?  Securely store and process credit card numbers?</htmltext>
<tokenext>It seems like too many people think encryption is only about scrambling data until it looks hard to recover .
This is n't just a knock against self taught programmers , but I do tend to see it slightly more often in self taught individuals ( including myself ; when I was a kid I thought repeatedly XORing a password with plaintext was a great idea until I figured out how to automatically recover the passphrase from the ciphertext with statistical analysis a few years later ) .
Anyone who 's looked even slightly deeper knows that cryptography is seriously hard and involves knowing advanced mathematics and learning about every advanced published attack before attempting to design a cipher .
Even if you pick trusted cryptosystems , there are timing attacks , watermarking attacks , man in the middle attacks , side channel attacks , and any number of other security problems that have to be addressed in the system using the cryptographic primitives .
General security is hard , but secure cryptography is arguably even harder .
You might think that a general programmer wo n't run into problems involving cryptography very often , but how many programs or web sites need to manage users and permissions ?
Store passwords that are n't vulnerable to rainbow tables ?
Transfer data over the Internet to another trusted host or user ?
Securely store and process credit card numbers ?</tokentext>
<sentencetext>It seems like too many people think encryption is only about scrambling data until it looks hard to recover.
This isn't just a knock against self taught programmers, but I do tend to see it slightly more often in self taught individuals (including myself; when I was a kid I thought repeatedly XORing a password with plaintext was a great idea until I figured out how to automatically recover the passphrase from the ciphertext with statistical analysis a few years later).
Anyone who's looked even slightly deeper knows that cryptography is seriously hard and involves knowing advanced mathematics and learning about every advanced published attack before attempting to design a cipher.
Even if you pick trusted cryptosystems, there are timing attacks, watermarking attacks, man in the middle attacks, side channel attacks, and any number of other security problems that have to be addressed in the system using the cryptographic primitives.
General security is hard, but secure cryptography is arguably even harder.
You might think that a general programmer won't run into problems involving cryptography very often, but how many programs or web sites need to manage users and permissions?
Store passwords that aren't vulnerable to rainbow tables?
Transfer data over the Internet to another trusted host or user?
Securely store and process credit card numbers?</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203234</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>Anonymous</author>
	<datestamp>1266570720000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>All of these are important things you need to understand before you should be allowed to call yourself a good programmer. Coming from an engineering background, before I decided to go back to school and get an additional degree in Computer Science, I can tell you that no matter what you think you probably don't know how to program well. I was always interested in computers and programming before going through CS and thought that I was pretty good and efficient at writing programs. Boy was I wrong. Engineers are probably the worst programmers out there, it's easy for an engineer to get carried away with trying to be efficient and then end up just doing the opposite. Compilers these days are quite well optimized. An engineer trying to write optimized code is probably just going to make it harder on the compiler. Until you have the basic theory and insight on what goes on behind the scenes you are dangerous.</p></htmltext>
<tokenext>All of these are important things you need to understand before you should be allowed to call yourself a good programmer .
Coming from an engineering background , before I decided to go back to school and get an additional degree in Computer Science , I can tell you that no matter what you think you probably do n't know how to program well .
I was always interested in computers and programming before going through CS and thought that I was pretty good and efficient at writing programs .
Boy was I wrong .
Engineers are probably the worst programmers out there , it 's easy for an engineer to get carried away with trying to be efficient and then end up just doing the opposite .
Compilers these days are quite well optimized .
An engineer trying to write optimized code is probably just going to make it harder on the compiler .
Until you have the basic theory and insight on what goes on behind the scenes you are dangerous .</tokentext>
<sentencetext>All of these are important things you need to understand before you should be allowed to call yourself a good programmer.
Coming from an engineering background, before I decided to go back to school and get an additional degree in Computer Science, I can tell you that no matter what you think you probably don't know how to program well.
I was always interested in computers and programming before going through CS and thought that I was pretty good and efficient at writing programs.
Boy was I wrong.
Engineers are probably the worst programmers out there, it's easy for an engineer to get carried away with trying to be efficient and then end up just doing the opposite.
Compilers these days are quite well optimized.
An engineer trying to write optimized code is probably just going to make it harder on the compiler.
Until you have the basic theory and insight on what goes on behind the scenes you are dangerous.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200110</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>SurgeryByNumbers</author>
	<datestamp>1266599100000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>In my experience, the culture shock for new grads wears off in about 6 months to a year.  Either they get with the program and start doing the work real-world right or they find a way to disappear into a giant corporate environment.  Those that get with the program quickly become more valuable than self-taught programmers who don't understand the fundamentals well.</htmltext>
<tokenext>In my experience , the culture shock for new grads wears off in about 6 months to a year .
Either they get with the program and start doing the work real-world right or they find a way to disappear into a giant corporate environment .
Those that get with the program quickly become more valuable than self-taught programmers who do n't understand the fundamentals well .</tokentext>
<sentencetext>In my experience, the culture shock for new grads wears off in about 6 months to a year.
Either they get with the program and start doing the work real-world right or they find a way to disappear into a giant corporate environment.
Those that get with the program quickly become more valuable than self-taught programmers who don't understand the fundamentals well.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31204452</id>
	<title>well..</title>
	<author>jasno</author>
	<datestamp>1266575580000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>What do you want - to be an effective programmer, or to understand CS theory that you may, depending on your specialty, never get to use?</p><p>I'm biased - I came into programming as an EE who landed a job as an embedded software engineer.  I tend to work on low-level driver issues(race conditions, improper locking, buffering issues), but I've done contract work on VB6, python, C++, bash scripts, Java, OpenGL, digital video, etc...  Beyond a good understanding of locking, buffering(be able to implement a circular buffer in your sleep), and how computers function(down to boolean logic, although I find comfort in knowing how to bias a transistor), I don't think you need most of what a CS guy spends his time on.</p><p>I barely know what turing complete means, and I couldn't give a shit about the towers of hanoi or a traveling salesman.  None of that has ever come up in my line of work.  If you don't already know about that stuff, chances are that you're not smart enough to land the type of job where you would use it.</p><p>Object oriented design took me a few years to really get.  You just need to apply it, and apply it again, and apply it wrong, and see how other people have applied it wrong(no good definition of wrong here, but you'll know it when you see it).  Eventually you'll get a better feel for it.  I still can't architect as well as some CS friends of mine, but I consider those guys geniuses, in contrast with a lot of CS educated morons.</p><p>Write a multi-tasking OS.  I wrote a simple one for the 68HC12 a few years back and it taught me a lot about what you need, and what you don't.  You could probably find an emulator so you don't have the added challenge of bringing up a development board, but you really should be able to bring up a development board(write mem tests, exercise the hardware(serial ports, gpio, timers, etc)).</p><p>Do it all when you're young.  Life catches up with you by the time you're 30.</p></htmltext>
<tokenext>What do you want - to be an effective programmer , or to understand CS theory that you may , depending on your specialty , never get to use ? I 'm biased - I came into programming as an EE who landed a job as an embedded software engineer .
I tend to work on low-level driver issues ( race conditions , improper locking , buffering issues ) , but I 've done contract work on VB6 , python , C + + , bash scripts , Java , OpenGL , digital video , etc... Beyond a good understanding of locking , buffering ( be able to implement a circular buffer in your sleep ) , and how computers function ( down to boolean logic , although I find comfort in knowing how to bias a transistor ) , I do n't think you need most of what a CS guy spends his time on.I barely know what turing complete means , and I could n't give a shit about the towers of hanoi or a traveling salesman .
None of that has ever come up in my line of work .
If you do n't already know about that stuff , chances are that you 're not smart enough to land the type of job where you would use it.Object oriented design took me a few years to really get .
You just need to apply it , and apply it again , and apply it wrong , and see how other people have applied it wrong ( no good definition of wrong here , but you 'll know it when you see it ) .
Eventually you 'll get a better feel for it .
I still ca n't architect as well as some CS friends of mine , but I consider those guys geniuses , in contrast with a lot of CS educated morons.Write a multi-tasking OS .
I wrote a simple one for the 68HC12 a few years back and it taught me a lot about what you need , and what you do n't .
You could probably find an emulator so you do n't have the added challenge of bringing up a development board , but you really should be able to bring up a development board ( write mem tests , exercise the hardware ( serial ports , gpio , timers , etc ) ) .Do it all when you 're young .
Life catches up with you by the time you 're 30 .</tokentext>
<sentencetext>What do you want - to be an effective programmer, or to understand CS theory that you may, depending on your specialty, never get to use?I'm biased - I came into programming as an EE who landed a job as an embedded software engineer.
I tend to work on low-level driver issues(race conditions, improper locking, buffering issues), but I've done contract work on VB6, python, C++, bash scripts, Java, OpenGL, digital video, etc...  Beyond a good understanding of locking, buffering(be able to implement a circular buffer in your sleep), and how computers function(down to boolean logic, although I find comfort in knowing how to bias a transistor), I don't think you need most of what a CS guy spends his time on.I barely know what turing complete means, and I couldn't give a shit about the towers of hanoi or a traveling salesman.
None of that has ever come up in my line of work.
If you don't already know about that stuff, chances are that you're not smart enough to land the type of job where you would use it.Object oriented design took me a few years to really get.
You just need to apply it, and apply it again, and apply it wrong, and see how other people have applied it wrong(no good definition of wrong here, but you'll know it when you see it).
Eventually you'll get a better feel for it.
I still can't architect as well as some CS friends of mine, but I consider those guys geniuses, in contrast with a lot of CS educated morons.Write a multi-tasking OS.
I wrote a simple one for the 68HC12 a few years back and it taught me a lot about what you need, and what you don't.
You could probably find an emulator so you don't have the added challenge of bringing up a development board, but you really should be able to bring up a development board(write mem tests, exercise the hardware(serial ports, gpio, timers, etc)).Do it all when you're young.
Life catches up with you by the time you're 30.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200034</id>
	<title>What I look for when I hire</title>
	<author>jjhplus9</author>
	<datestamp>1266598680000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>As well as a broad range of basic skills, there are a couple of Comp. Sci. skills that I like to see, and without these I tend to be more cautious:

- Compiler Construction
- Formal Methods
- Parallel Programming

These broad heading are the general indicator of what I am looking for, I think they give the kind of depth that you will come back to again and again in a career.

So I look at what options my prospective employee has taken in their Comp. Sci. Degree.

If I see optional courses taken that fall into the categories above, they go to the top of the list.  If they have instead taken lots of multimedia, web or softer options instead I will be more cautious (unless of course I am looking for these particular skills)</htmltext>
<tokenext>As well as a broad range of basic skills , there are a couple of Comp .
Sci. skills that I like to see , and without these I tend to be more cautious : - Compiler Construction - Formal Methods - Parallel Programming These broad heading are the general indicator of what I am looking for , I think they give the kind of depth that you will come back to again and again in a career .
So I look at what options my prospective employee has taken in their Comp .
Sci. Degree .
If I see optional courses taken that fall into the categories above , they go to the top of the list .
If they have instead taken lots of multimedia , web or softer options instead I will be more cautious ( unless of course I am looking for these particular skills )</tokentext>
<sentencetext>As well as a broad range of basic skills, there are a couple of Comp.
Sci. skills that I like to see, and without these I tend to be more cautious:

- Compiler Construction
- Formal Methods
- Parallel Programming

These broad heading are the general indicator of what I am looking for, I think they give the kind of depth that you will come back to again and again in a career.
So I look at what options my prospective employee has taken in their Comp.
Sci. Degree.
If I see optional courses taken that fall into the categories above, they go to the top of the list.
If they have instead taken lots of multimedia, web or softer options instead I will be more cautious (unless of course I am looking for these particular skills)</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199572</id>
	<title>Algorithms, data structures, systems</title>
	<author>ColonelPanic</author>
	<datestamp>1266596580000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>2</modscore>
	<htmltext><p>If you know your algorithms and data structures, and have a firm grasp of the architecture of modern computer systems, you'll be way ahead of a depressingly large proportion of people with degrees in CS that come past me in interviews.</p><p>The most informative and entertaining book I can recommend on algorithms is Bentley's "Programming Pearls".</p></htmltext>
<tokenext>If you know your algorithms and data structures , and have a firm grasp of the architecture of modern computer systems , you 'll be way ahead of a depressingly large proportion of people with degrees in CS that come past me in interviews.The most informative and entertaining book I can recommend on algorithms is Bentley 's " Programming Pearls " .</tokentext>
<sentencetext>If you know your algorithms and data structures, and have a firm grasp of the architecture of modern computer systems, you'll be way ahead of a depressingly large proportion of people with degrees in CS that come past me in interviews.The most informative and entertaining book I can recommend on algorithms is Bentley's "Programming Pearls".</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200134</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>CodingHero</author>
	<datestamp>1266599220000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>3</modscore>
	<htmltext>To be fair, I got BS degrees in Computer and Software Engineering, but if we consider only the required courses from both these curriculums, I gained:
<br>- NO education on design patterns
<br>- A very limited understanding of how to apply big O analysis to an algorithm (although I do understand what it represents)
<br>- Almost NO attention to "proper" OO analysis and design.  Any knowledge of this I have is from personal experience during school and professionally
<br>- only a cursory look at threading.
<br>- A good understanding of state machines
<br>- Exposure to language construction (via a required course on compilers)
<br>- A good understanding of computer architecture
<br> <br>What one learns in an academic environment is very much dependent on the core curriculum the school has and thus a self-taught programmer may not be at much of a disadvantage at all.</htmltext>
<tokenext>To be fair , I got BS degrees in Computer and Software Engineering , but if we consider only the required courses from both these curriculums , I gained : - NO education on design patterns - A very limited understanding of how to apply big O analysis to an algorithm ( although I do understand what it represents ) - Almost NO attention to " proper " OO analysis and design .
Any knowledge of this I have is from personal experience during school and professionally - only a cursory look at threading .
- A good understanding of state machines - Exposure to language construction ( via a required course on compilers ) - A good understanding of computer architecture What one learns in an academic environment is very much dependent on the core curriculum the school has and thus a self-taught programmer may not be at much of a disadvantage at all .</tokentext>
<sentencetext>To be fair, I got BS degrees in Computer and Software Engineering, but if we consider only the required courses from both these curriculums, I gained:
- NO education on design patterns
- A very limited understanding of how to apply big O analysis to an algorithm (although I do understand what it represents)
- Almost NO attention to "proper" OO analysis and design.
Any knowledge of this I have is from personal experience during school and professionally
- only a cursory look at threading.
- A good understanding of state machines
- Exposure to language construction (via a required course on compilers)
- A good understanding of computer architecture
 What one learns in an academic environment is very much dependent on the core curriculum the school has and thus a self-taught programmer may not be at much of a disadvantage at all.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201130</id>
	<title>Its the study materials, not being self-taught</title>
	<author>perpenso</author>
	<datestamp>1266603480000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Gaps between those that are self-taught and those who are university educated are primarily due to their study materials.  Those going down the university path have an advantage due to broader and more in-depth coverage (particularly with the underlying theory and math).  I've found solutions to problems coming from topics I never expected to be relevant and topics I may have never studied on my own.  However I have a friend who is primarily self-taught and who is blessed with the intelligence and motivation to read a broad collection of university textbook level materials on his own.  For such an individual there is really no gap.<br> <br>

So if you want to be a video game programmer do not go to your local shopping mall's Barnes and Noble bookstore and buy books on C++ and OpenGL.  Go to your local college/university bookstore and buy *textbooks* on Data Structures and Algorithms, Computer Architecture, Computer Graphics, Databases, Networking,<nobr> <wbr></nobr>...  Doing so will vastly improve your odds of making it.<br> <br>

--<br>
<a href="http://www.perpenso.com/calc/" title="perpenso.com" rel="nofollow">Perpenso Calc</a> [perpenso.com] for iPhone and iPod touch, scientific and bill/tip calculator, fractions, complex numbers, RPN</htmltext>
<tokenext>Gaps between those that are self-taught and those who are university educated are primarily due to their study materials .
Those going down the university path have an advantage due to broader and more in-depth coverage ( particularly with the underlying theory and math ) .
I 've found solutions to problems coming from topics I never expected to be relevant and topics I may have never studied on my own .
However I have a friend who is primarily self-taught and who is blessed with the intelligence and motivation to read a broad collection of university textbook level materials on his own .
For such an individual there is really no gap .
So if you want to be a video game programmer do not go to your local shopping mall 's Barnes and Noble bookstore and buy books on C + + and OpenGL .
Go to your local college/university bookstore and buy * textbooks * on Data Structures and Algorithms , Computer Architecture , Computer Graphics , Databases , Networking , ... Doing so will vastly improve your odds of making it .
-- Perpenso Calc [ perpenso.com ] for iPhone and iPod touch , scientific and bill/tip calculator , fractions , complex numbers , RPN</tokentext>
<sentencetext>Gaps between those that are self-taught and those who are university educated are primarily due to their study materials.
Those going down the university path have an advantage due to broader and more in-depth coverage (particularly with the underlying theory and math).
I've found solutions to problems coming from topics I never expected to be relevant and topics I may have never studied on my own.
However I have a friend who is primarily self-taught and who is blessed with the intelligence and motivation to read a broad collection of university textbook level materials on his own.
For such an individual there is really no gap.
So if you want to be a video game programmer do not go to your local shopping mall's Barnes and Noble bookstore and buy books on C++ and OpenGL.
Go to your local college/university bookstore and buy *textbooks* on Data Structures and Algorithms, Computer Architecture, Computer Graphics, Databases, Networking, ...  Doing so will vastly improve your odds of making it.
--
Perpenso Calc [perpenso.com] for iPhone and iPod touch, scientific and bill/tip calculator, fractions, complex numbers, RPN</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199298</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199298</id>
	<title>Self-taught too.</title>
	<author>Anonymous</author>
	<datestamp>1266595140000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>4</modscore>
	<htmltext>Being self taught myself, I think the biggest downside is some of the strategies and standards that are taught in the mainstream curriculum (IE: how to properly use the object-oriented model, etc.).  Especially when I first started out, my code may get the job done, but it wasn't the cleanest or best approach. Luckily, I think it will come to you in time if you focus on improving your code.</htmltext>
<tokenext>Being self taught myself , I think the biggest downside is some of the strategies and standards that are taught in the mainstream curriculum ( IE : how to properly use the object-oriented model , etc. ) .
Especially when I first started out , my code may get the job done , but it was n't the cleanest or best approach .
Luckily , I think it will come to you in time if you focus on improving your code .</tokentext>
<sentencetext>Being self taught myself, I think the biggest downside is some of the strategies and standards that are taught in the mainstream curriculum (IE: how to properly use the object-oriented model, etc.).
Especially when I first started out, my code may get the job done, but it wasn't the cleanest or best approach.
Luckily, I think it will come to you in time if you focus on improving your code.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203522</id>
	<title>Algorithms, design patterns and data structures</title>
	<author>Anonymous</author>
	<datestamp>1266571740000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Get some good books on Algorithms, design patterns and data structures. This will give you more breadth to your knowledge. My first book was Knuthe's "Sorting and Searching Algorithms". I of course couldn't understand everything in it, but just reading about the different algorithms made me aware of all of the work that had been done that I could pull from if I needed something.</p><p>I always remember my first boss who was an engineer and a self taught programmer looking at my complicated and efficient quick sort program and telling me that it was ridiculous because you could write a sort program in 3 lines of code. ( I think he had seen a print out of a bubble sort in Byte magazine.) I of course wanted to use the system sort program built into the VMS on our VAX, but he wanted me to write a custom sort program.</p></htmltext>
<tokenext>Get some good books on Algorithms , design patterns and data structures .
This will give you more breadth to your knowledge .
My first book was Knuthe 's " Sorting and Searching Algorithms " .
I of course could n't understand everything in it , but just reading about the different algorithms made me aware of all of the work that had been done that I could pull from if I needed something.I always remember my first boss who was an engineer and a self taught programmer looking at my complicated and efficient quick sort program and telling me that it was ridiculous because you could write a sort program in 3 lines of code .
( I think he had seen a print out of a bubble sort in Byte magazine .
) I of course wanted to use the system sort program built into the VMS on our VAX , but he wanted me to write a custom sort program .</tokentext>
<sentencetext>Get some good books on Algorithms, design patterns and data structures.
This will give you more breadth to your knowledge.
My first book was Knuthe's "Sorting and Searching Algorithms".
I of course couldn't understand everything in it, but just reading about the different algorithms made me aware of all of the work that had been done that I could pull from if I needed something.I always remember my first boss who was an engineer and a self taught programmer looking at my complicated and efficient quick sort program and telling me that it was ridiculous because you could write a sort program in 3 lines of code.
( I think he had seen a print out of a bubble sort in Byte magazine.
) I of course wanted to use the system sort program built into the VMS on our VAX, but he wanted me to write a custom sort program.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202834</id>
	<title>Oh that's an easy one</title>
	<author>NotSoHeavyD3</author>
	<datestamp>1266612240000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>How full of bullshit your superiors are. I mean you'll deal with professors and administrators who are completely full of shit. This will prepare you for your bosses who will be so full of shit that the only way they could be more full of shit would require the use of a pump, a hose, and a bag of manure.</htmltext>
<tokenext>How full of bullshit your superiors are .
I mean you 'll deal with professors and administrators who are completely full of shit .
This will prepare you for your bosses who will be so full of shit that the only way they could be more full of shit would require the use of a pump , a hose , and a bag of manure .</tokentext>
<sentencetext>How full of bullshit your superiors are.
I mean you'll deal with professors and administrators who are completely full of shit.
This will prepare you for your bosses who will be so full of shit that the only way they could be more full of shit would require the use of a pump, a hose, and a bag of manure.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200068</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>david.emery</author>
	<datestamp>1266598800000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext><p>That's a good question, too.</p><p>I'd suggest<br>
&nbsp; &nbsp; &nbsp; a.  Debugging techniques (but then I strongly prefer design/language approaches that minimize debugging in the first place)<br>
&nbsp; &nbsp; &nbsp; b.  Programming-in-the-large, including (i) program structure; (ii) maintenance/documentation considerations  (That's true for programmers who have worked on large, well-run projects.)<br>
&nbsp; &nbsp; &nbsp; c.  MAYBE multiple programming languages - As I wrote in another posting on this thread, I will not hire a mono-lingual programmer.  Too often people coming out of schools have been exposed to one programming language, the popular language-du-jour.  If you've been around long enough you've probably worked in several different languages and seen how each language points you towards a certain set of solutions.<br>
&nbsp; &nbsp; d.  Understanding of the non-coding aspects, such as design documentation, etc.  Again that's true for people who have worked in well-run shops.  The rate of illiteracy among programmers isn't getting any better, and in any project &gt; 5 people you'll spend as much time doing reading, writing, talking, etc, as you will in front of a computer typing in code.</p></htmltext>
<tokenext>That 's a good question , too.I 'd suggest       a. Debugging techniques ( but then I strongly prefer design/language approaches that minimize debugging in the first place )       b. Programming-in-the-large , including ( i ) program structure ; ( ii ) maintenance/documentation considerations ( That 's true for programmers who have worked on large , well-run projects .
)       c. MAYBE multiple programming languages - As I wrote in another posting on this thread , I will not hire a mono-lingual programmer .
Too often people coming out of schools have been exposed to one programming language , the popular language-du-jour .
If you 've been around long enough you 've probably worked in several different languages and seen how each language points you towards a certain set of solutions .
    d. Understanding of the non-coding aspects , such as design documentation , etc .
Again that 's true for people who have worked in well-run shops .
The rate of illiteracy among programmers is n't getting any better , and in any project &gt; 5 people you 'll spend as much time doing reading , writing , talking , etc , as you will in front of a computer typing in code .</tokentext>
<sentencetext>That's a good question, too.I'd suggest
      a.  Debugging techniques (but then I strongly prefer design/language approaches that minimize debugging in the first place)
      b.  Programming-in-the-large, including (i) program structure; (ii) maintenance/documentation considerations  (That's true for programmers who have worked on large, well-run projects.
)
      c.  MAYBE multiple programming languages - As I wrote in another posting on this thread, I will not hire a mono-lingual programmer.
Too often people coming out of schools have been exposed to one programming language, the popular language-du-jour.
If you've been around long enough you've probably worked in several different languages and seen how each language points you towards a certain set of solutions.
    d.  Understanding of the non-coding aspects, such as design documentation, etc.
Again that's true for people who have worked in well-run shops.
The rate of illiteracy among programmers isn't getting any better, and in any project &gt; 5 people you'll spend as much time doing reading, writing, talking, etc, as you will in front of a computer typing in code.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31207336</id>
	<title>Try this</title>
	<author>WhiteHorse-The Origi</author>
	<datestamp>1266595680000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Discrete maths(1 book <a href="http://www.cimt.plymouth.ac.uk/projects/mepres/alevel/alevel.htm" title="plymouth.ac.uk" rel="nofollow">http://www.cimt.plymouth.ac.uk/projects/mepres/alevel/alevel.htm</a> [plymouth.ac.uk]) and wikipedia(1 list <a href="http://en.wikipedia.org/wiki/List\_of\_computer\_programming\_topics" title="wikipedia.org" rel="nofollow">http://en.wikipedia.org/wiki/List\_of\_computer\_programming\_topics</a> [wikipedia.org]).

I also have a physics degree and taught myself programming. It's important to realize you'll never be a member of "the in crowd" until you have a piece of paper from an overpriced university. It's the only way unintelligent people can distinguish between programmers and it gives them an easy out if you suck.</htmltext>
<tokenext>Discrete maths ( 1 book http : //www.cimt.plymouth.ac.uk/projects/mepres/alevel/alevel.htm [ plymouth.ac.uk ] ) and wikipedia ( 1 list http : //en.wikipedia.org/wiki/List \ _of \ _computer \ _programming \ _topics [ wikipedia.org ] ) .
I also have a physics degree and taught myself programming .
It 's important to realize you 'll never be a member of " the in crowd " until you have a piece of paper from an overpriced university .
It 's the only way unintelligent people can distinguish between programmers and it gives them an easy out if you suck .</tokentext>
<sentencetext>Discrete maths(1 book http://www.cimt.plymouth.ac.uk/projects/mepres/alevel/alevel.htm [plymouth.ac.uk]) and wikipedia(1 list http://en.wikipedia.org/wiki/List\_of\_computer\_programming\_topics [wikipedia.org]).
I also have a physics degree and taught myself programming.
It's important to realize you'll never be a member of "the in crowd" until you have a piece of paper from an overpriced university.
It's the only way unintelligent people can distinguish between programmers and it gives them an easy out if you suck.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31209784</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>Pictish Prince</author>
	<datestamp>1266678300000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>I might add to this list: Recursion.</p></div><p>IMO, if you don't understand recursion <i>before</i> you learn to program, you have no business being a programmer.</p></div>
	</htmltext>
<tokenext>I might add to this list : Recursion.IMO , if you do n't understand recursion before you learn to program , you have no business being a programmer .</tokentext>
<sentencetext>I might add to this list: Recursion.IMO, if you don't understand recursion before you learn to program, you have no business being a programmer.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200224</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199790</id>
	<title>Big-O. No, not *that* big O.</title>
	<author>Anonymous</author>
	<datestamp>1266597720000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I went to college to get a comp-sci degree after I already had several years of experience in the real world. The one thing that I took away from that education that I had not stumbled upon naturally was Big-O notation. Specifically, how it describes the time and space efficiency of different data structures and algorithms. It really comes in handy when trying to optimize. There have been several where I had become focused on optimizing the crap out of an inner loop, only to realize that if I switched to a different data structure I'd get much faster O(log n) performance.</p><p>Other than that, many people only experience low-level C and assembly programming while at school. But you mention that you have C++ experience, so you're probably already well familiar with segfaults and buffer overflows.</p><p>Lastly, Structure and Interpretation of Computer Programs (SICP) is a great read. The levels of recursion and abstraction that it employs will often blow your mind. Sadly, I can't use that kind of coding in the real world because I have to write "maintainable" code and most corporate programmers don't want to have their mind blown.</p></htmltext>
<tokenext>I went to college to get a comp-sci degree after I already had several years of experience in the real world .
The one thing that I took away from that education that I had not stumbled upon naturally was Big-O notation .
Specifically , how it describes the time and space efficiency of different data structures and algorithms .
It really comes in handy when trying to optimize .
There have been several where I had become focused on optimizing the crap out of an inner loop , only to realize that if I switched to a different data structure I 'd get much faster O ( log n ) performance.Other than that , many people only experience low-level C and assembly programming while at school .
But you mention that you have C + + experience , so you 're probably already well familiar with segfaults and buffer overflows.Lastly , Structure and Interpretation of Computer Programs ( SICP ) is a great read .
The levels of recursion and abstraction that it employs will often blow your mind .
Sadly , I ca n't use that kind of coding in the real world because I have to write " maintainable " code and most corporate programmers do n't want to have their mind blown .</tokentext>
<sentencetext>I went to college to get a comp-sci degree after I already had several years of experience in the real world.
The one thing that I took away from that education that I had not stumbled upon naturally was Big-O notation.
Specifically, how it describes the time and space efficiency of different data structures and algorithms.
It really comes in handy when trying to optimize.
There have been several where I had become focused on optimizing the crap out of an inner loop, only to realize that if I switched to a different data structure I'd get much faster O(log n) performance.Other than that, many people only experience low-level C and assembly programming while at school.
But you mention that you have C++ experience, so you're probably already well familiar with segfaults and buffer overflows.Lastly, Structure and Interpretation of Computer Programs (SICP) is a great read.
The levels of recursion and abstraction that it employs will often blow your mind.
Sadly, I can't use that kind of coding in the real world because I have to write "maintainable" code and most corporate programmers don't want to have their mind blown.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31206918</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>The End Of Days</author>
	<datestamp>1266591060000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>The point of design patterns is not to provide a catalog of common solutions, it is to formulate a common language to describe the solution space.  They are not an implementation tool, they are a communication tool.</p><p>Understanding the purpose of the tools is the first step to using them correctly.  Disparaging the tools because fools misuse them is just as foolish as misusing them.</p></htmltext>
<tokenext>The point of design patterns is not to provide a catalog of common solutions , it is to formulate a common language to describe the solution space .
They are not an implementation tool , they are a communication tool.Understanding the purpose of the tools is the first step to using them correctly .
Disparaging the tools because fools misuse them is just as foolish as misusing them .</tokentext>
<sentencetext>The point of design patterns is not to provide a catalog of common solutions, it is to formulate a common language to describe the solution space.
They are not an implementation tool, they are a communication tool.Understanding the purpose of the tools is the first step to using them correctly.
Disparaging the tools because fools misuse them is just as foolish as misusing them.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199864</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31209052</id>
	<title>Experience</title>
	<author>seangee</author>
	<datestamp>1266666120000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Applies to both self and institution taught.  I came through the self taught route and have been developing software (and employing developers) for 20 years.

Theory is great but a natural developer will absorb that even if self taught - and I do believe developers are born rather than made. Many of the mediocre developers are simply doing the wrong job and will never excel because they don't have the right mindset.

In the real world I am far more interested in someone who will deliver the required solution than what formal training they have had. And that (usually) means somebody with a track record of successful delivery</htmltext>
<tokenext>Applies to both self and institution taught .
I came through the self taught route and have been developing software ( and employing developers ) for 20 years .
Theory is great but a natural developer will absorb that even if self taught - and I do believe developers are born rather than made .
Many of the mediocre developers are simply doing the wrong job and will never excel because they do n't have the right mindset .
In the real world I am far more interested in someone who will deliver the required solution than what formal training they have had .
And that ( usually ) means somebody with a track record of successful delivery</tokentext>
<sentencetext>Applies to both self and institution taught.
I came through the self taught route and have been developing software (and employing developers) for 20 years.
Theory is great but a natural developer will absorb that even if self taught - and I do believe developers are born rather than made.
Many of the mediocre developers are simply doing the wrong job and will never excel because they don't have the right mindset.
In the real world I am far more interested in someone who will deliver the required solution than what formal training they have had.
And that (usually) means somebody with a track record of successful delivery</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199996</id>
	<title>Finite State Machines</title>
	<author>Anonymous</author>
	<datestamp>1266598500000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I'll second Finite State Machines.</p><p>More times than I can count, I've drawn a finite state machine on paper and gone on to implement it in a high level language. Though I feel awfully old fashioned when I do it, they're great for parsing stuff and handling incoming data streams. The results are typically high performance and bullet proof.</p></htmltext>
<tokenext>I 'll second Finite State Machines.More times than I can count , I 've drawn a finite state machine on paper and gone on to implement it in a high level language .
Though I feel awfully old fashioned when I do it , they 're great for parsing stuff and handling incoming data streams .
The results are typically high performance and bullet proof .</tokentext>
<sentencetext>I'll second Finite State Machines.More times than I can count, I've drawn a finite state machine on paper and gone on to implement it in a high level language.
Though I feel awfully old fashioned when I do it, they're great for parsing stuff and handling incoming data streams.
The results are typically high performance and bullet proof.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31208960</id>
	<title>Learn LISP</title>
	<author>Zoko Siman</author>
	<datestamp>1266664080000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I just hosted Richard Stallman at my university (http://csee.wvu.edu/rms video coming soon). After the lecture was finished a student asked him "What can I do to be a better programmer" to which he responded "Learn LISP."</p><p>I can say from my experience with the language, that RMS, ESR, and PG are all right. Learn LISP. It will change how you think.</p></htmltext>
<tokenext>I just hosted Richard Stallman at my university ( http : //csee.wvu.edu/rms video coming soon ) .
After the lecture was finished a student asked him " What can I do to be a better programmer " to which he responded " Learn LISP .
" I can say from my experience with the language , that RMS , ESR , and PG are all right .
Learn LISP .
It will change how you think .</tokentext>
<sentencetext>I just hosted Richard Stallman at my university (http://csee.wvu.edu/rms video coming soon).
After the lecture was finished a student asked him "What can I do to be a better programmer" to which he responded "Learn LISP.
"I can say from my experience with the language, that RMS, ESR, and PG are all right.
Learn LISP.
It will change how you think.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202930</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>monkeySauce</author>
	<datestamp>1266612720000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>So what university did you go to? It would be useful for others to know which school to avoid.</p></htmltext>
<tokenext>So what university did you go to ?
It would be useful for others to know which school to avoid .</tokentext>
<sentencetext>So what university did you go to?
It would be useful for others to know which school to avoid.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200134</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31205650</id>
	<title>My recommendations</title>
	<author>jon3k</author>
	<datestamp>1266581100000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>To cover 95\% of the work done by your average programmer just go to a local university and see if you can audit a data structures class.  This is assuming you're already competent in general.</htmltext>
<tokenext>To cover 95 \ % of the work done by your average programmer just go to a local university and see if you can audit a data structures class .
This is assuming you 're already competent in general .</tokentext>
<sentencetext>To cover 95\% of the work done by your average programmer just go to a local university and see if you can audit a data structures class.
This is assuming you're already competent in general.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200678</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>Corporate Drone</author>
	<datestamp>1266601380000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Self-taught folks tend to have less in their toolkits -- when all you've learned is a hammer, everything looks like a nail.  Then, when trying to do something different, they try to take their hammer and "invent" a screwdriver out of it.  </p><p>kids right out of school aren't ready to take practical problems and successfully solve them -- that work ethic tends to take a year or two to get down (and rightly so, since CS programs aren't I.T.-drone-cookie-cutter factories), but at least they know enough about the landscape to recognize what tools to use.</p></htmltext>
<tokenext>Self-taught folks tend to have less in their toolkits -- when all you 've learned is a hammer , everything looks like a nail .
Then , when trying to do something different , they try to take their hammer and " invent " a screwdriver out of it .
kids right out of school are n't ready to take practical problems and successfully solve them -- that work ethic tends to take a year or two to get down ( and rightly so , since CS programs are n't I.T.-drone-cookie-cutter factories ) , but at least they know enough about the landscape to recognize what tools to use .</tokentext>
<sentencetext>Self-taught folks tend to have less in their toolkits -- when all you've learned is a hammer, everything looks like a nail.
Then, when trying to do something different, they try to take their hammer and "invent" a screwdriver out of it.
kids right out of school aren't ready to take practical problems and successfully solve them -- that work ethic tends to take a year or two to get down (and rightly so, since CS programs aren't I.T.-drone-cookie-cutter factories), but at least they know enough about the landscape to recognize what tools to use.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31271124</id>
	<title>this might be almost interesting</title>
	<author>Anonymous</author>
	<datestamp>1267107600000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>anecdote:<br>via maxxed PDP-8/i and the free-for-the-asking DEC PDP8 &amp; 11 books I learned programming around 1975.<br>But at first I couldn't properly conceive of nested loops.   "linear thinking" ?<br>So I wrote an klugey/bruteforce/hack sort algorithm as part of a particular dice game for ASR33, using just one BASIC FOR/NEXT loop.<br>It's in the creative computing magazine jan/feb 1978.  In case you have one of those lying around, please feel free to<br>scan/post/criticize it and perhaps consider me a Slightly Less Anonymous Yet Still Embarassed Coward.</p></htmltext>
<tokenext>anecdote : via maxxed PDP-8/i and the free-for-the-asking DEC PDP8 &amp; 11 books I learned programming around 1975.But at first I could n't properly conceive of nested loops .
" linear thinking " ? So I wrote an klugey/bruteforce/hack sort algorithm as part of a particular dice game for ASR33 , using just one BASIC FOR/NEXT loop.It 's in the creative computing magazine jan/feb 1978 .
In case you have one of those lying around , please feel free toscan/post/criticize it and perhaps consider me a Slightly Less Anonymous Yet Still Embarassed Coward .</tokentext>
<sentencetext>anecdote:via maxxed PDP-8/i and the free-for-the-asking DEC PDP8 &amp; 11 books I learned programming around 1975.But at first I couldn't properly conceive of nested loops.
"linear thinking" ?So I wrote an klugey/bruteforce/hack sort algorithm as part of a particular dice game for ASR33, using just one BASIC FOR/NEXT loop.It's in the creative computing magazine jan/feb 1978.
In case you have one of those lying around, please feel free toscan/post/criticize it and perhaps consider me a Slightly Less Anonymous Yet Still Embarassed Coward.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199630</id>
	<title>Know....ledge?</title>
	<author>Anonymous</author>
	<datestamp>1266596940000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I've been programming Visual Basic for years!</p></htmltext>
<tokenext>I 've been programming Visual Basic for years !</tokentext>
<sentencetext>I've been programming Visual Basic for years!</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</id>
	<title>I'm Interested in the Opposite View</title>
	<author>moore.dustin</author>
	<datestamp>1266597300000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext>What gaps do schooled programmers have that self-taught programmers don't? While a self-taught programmer might go about getting the job done differently, I can almost always count on him to get it done. Programmers coming out of school often still have a horrible worth ethic, especially when compared to their self taught peers. Granted, I have a very limited experience, so I wouldn't cast that judgment over all, but I would be curious to here what others think.</htmltext>
<tokenext>What gaps do schooled programmers have that self-taught programmers do n't ?
While a self-taught programmer might go about getting the job done differently , I can almost always count on him to get it done .
Programmers coming out of school often still have a horrible worth ethic , especially when compared to their self taught peers .
Granted , I have a very limited experience , so I would n't cast that judgment over all , but I would be curious to here what others think .</tokentext>
<sentencetext>What gaps do schooled programmers have that self-taught programmers don't?
While a self-taught programmer might go about getting the job done differently, I can almost always count on him to get it done.
Programmers coming out of school often still have a horrible worth ethic, especially when compared to their self taught peers.
Granted, I have a very limited experience, so I wouldn't cast that judgment over all, but I would be curious to here what others think.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202114</id>
	<title>As Tolstoy said</title>
	<author>oren</author>
	<datestamp>1266608460000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>"Happy families are all alike; every unhappy family is unhappy in its own way". Same for self (or partially) taught developers. Each will have a different gap. It depends on the developer's interests, project history, etc. A self-taught game developer may have a solid grasp of 3D and analytic geometry, while a self-taught web developer may have a solid grasp of database theory. Presumably, a developer who went through academic training will know at least something about both (and many other issues) - depending which school he went too, but that's another discussion. So, bottom line is, "it depends".</htmltext>
<tokenext>" Happy families are all alike ; every unhappy family is unhappy in its own way " .
Same for self ( or partially ) taught developers .
Each will have a different gap .
It depends on the developer 's interests , project history , etc .
A self-taught game developer may have a solid grasp of 3D and analytic geometry , while a self-taught web developer may have a solid grasp of database theory .
Presumably , a developer who went through academic training will know at least something about both ( and many other issues ) - depending which school he went too , but that 's another discussion .
So , bottom line is , " it depends " .</tokentext>
<sentencetext>"Happy families are all alike; every unhappy family is unhappy in its own way".
Same for self (or partially) taught developers.
Each will have a different gap.
It depends on the developer's interests, project history, etc.
A self-taught game developer may have a solid grasp of 3D and analytic geometry, while a self-taught web developer may have a solid grasp of database theory.
Presumably, a developer who went through academic training will know at least something about both (and many other issues) - depending which school he went too, but that's another discussion.
So, bottom line is, "it depends".</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202262</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>Anonymous</author>
	<datestamp>1266609360000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>In my experience, students coming directly out of college CS programs are really weak in debugging, managing code across multiple files, CVS/source control, and keeping things simple.  I've been in several situations where code was so over-engineered with the latest CS approaches, that it was a monumental pain in the butt for people to actually use the system.  I've also seen a lot of students hanging on to a particular language they took a class in, rather than embracing several languages and using the one most appropriate for the task at hand.</p></htmltext>
<tokenext>In my experience , students coming directly out of college CS programs are really weak in debugging , managing code across multiple files , CVS/source control , and keeping things simple .
I 've been in several situations where code was so over-engineered with the latest CS approaches , that it was a monumental pain in the butt for people to actually use the system .
I 've also seen a lot of students hanging on to a particular language they took a class in , rather than embracing several languages and using the one most appropriate for the task at hand .</tokentext>
<sentencetext>In my experience, students coming directly out of college CS programs are really weak in debugging, managing code across multiple files, CVS/source control, and keeping things simple.
I've been in several situations where code was so over-engineered with the latest CS approaches, that it was a monumental pain in the butt for people to actually use the system.
I've also seen a lot of students hanging on to a particular language they took a class in, rather than embracing several languages and using the one most appropriate for the task at hand.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</id>
	<title>DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>LordKazan</author>
	<datestamp>1266596160000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>5</modscore>
	<htmltext><p><b>Design Patterns</b>: common "Template" solutions to regularly encountered problems/variations-on-that problem.  Be careful when learning these that you don't fall victim to "when you have a hammer, everything is a nail".    Also learn the Anti-patterns, wikipedia has a good list of anti-patterns.</p><p><b>Algorithms &amp; Data Structures</b>: Analysis, average running time Big O is most important, but understanding worst-case runtime is important too.  Designing algorithms vs knowing when to leverage an existing one.</p><p>the C++ standard library provides a great many of these, it has a high efficiency sort (from ), it has good collection data structures (vectors, linked lists, maps, etc)</p><p><b>Objected Oriented Analysis And Design</b>: Knowing when to make something an object, when and how to use inheritance and polymorphism, when to not make something an object.  Plain old data objects. separation of responsibility: UI is not logic, logic is not UI.</p><p><b>Threading</b>: proper thread synchronization techniques (mutexs, semaphores, conditions, etc), threading patterns such as Producer-Consumer, Inter-process communication</p><p><b>Automata &amp; Computability</b>: (Deterministic|Nondeterministic) Finite State Machines, Regular Languages, Turing Machines</p><p><b>Programming Languages</b>: LL language parsing &amp; rules authoring.</p><p><b>Computer Architecture</b>: Processor design, pipelining, caching, function calling conventions, etc - how to use this knowledge to write more efficient programs</p></htmltext>
<tokenext>Design Patterns : common " Template " solutions to regularly encountered problems/variations-on-that problem .
Be careful when learning these that you do n't fall victim to " when you have a hammer , everything is a nail " .
Also learn the Anti-patterns , wikipedia has a good list of anti-patterns.Algorithms &amp; Data Structures : Analysis , average running time Big O is most important , but understanding worst-case runtime is important too .
Designing algorithms vs knowing when to leverage an existing one.the C + + standard library provides a great many of these , it has a high efficiency sort ( from ) , it has good collection data structures ( vectors , linked lists , maps , etc ) Objected Oriented Analysis And Design : Knowing when to make something an object , when and how to use inheritance and polymorphism , when to not make something an object .
Plain old data objects .
separation of responsibility : UI is not logic , logic is not UI.Threading : proper thread synchronization techniques ( mutexs , semaphores , conditions , etc ) , threading patterns such as Producer-Consumer , Inter-process communicationAutomata &amp; Computability : ( Deterministic | Nondeterministic ) Finite State Machines , Regular Languages , Turing MachinesProgramming Languages : LL language parsing &amp; rules authoring.Computer Architecture : Processor design , pipelining , caching , function calling conventions , etc - how to use this knowledge to write more efficient programs</tokentext>
<sentencetext>Design Patterns: common "Template" solutions to regularly encountered problems/variations-on-that problem.
Be careful when learning these that you don't fall victim to "when you have a hammer, everything is a nail".
Also learn the Anti-patterns, wikipedia has a good list of anti-patterns.Algorithms &amp; Data Structures: Analysis, average running time Big O is most important, but understanding worst-case runtime is important too.
Designing algorithms vs knowing when to leverage an existing one.the C++ standard library provides a great many of these, it has a high efficiency sort (from ), it has good collection data structures (vectors, linked lists, maps, etc)Objected Oriented Analysis And Design: Knowing when to make something an object, when and how to use inheritance and polymorphism, when to not make something an object.
Plain old data objects.
separation of responsibility: UI is not logic, logic is not UI.Threading: proper thread synchronization techniques (mutexs, semaphores, conditions, etc), threading patterns such as Producer-Consumer, Inter-process communicationAutomata &amp; Computability: (Deterministic|Nondeterministic) Finite State Machines, Regular Languages, Turing MachinesProgramming Languages: LL language parsing &amp; rules authoring.Computer Architecture: Processor design, pipelining, caching, function calling conventions, etc - how to use this knowledge to write more efficient programs</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201320</id>
	<title>So much emphasis on Software Engineering...</title>
	<author>Unoriginal\_Nickname</author>
	<datestamp>1266604260000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>There's way too much emphasis on Software Engineering in these comments. Multithreading? Self-taught programmers are the only people who ever have the time to study IA-32 and associated errata to the point where they're able to write a reliable threading library. Object-oriented design? Computer architecture? Design patterns? All of this is easily within the reach of a self-taught programmer.</p><p>Here's my answer: self-taught programmers will not learn computability theory, complexity (incl. real analysis), classical algorithms/data structures, discrete math, combinatorics or numerical methods. Other than that, a self-taught programmer will probably be much better at the purely mechanical part.</p></htmltext>
<tokenext>There 's way too much emphasis on Software Engineering in these comments .
Multithreading ? Self-taught programmers are the only people who ever have the time to study IA-32 and associated errata to the point where they 're able to write a reliable threading library .
Object-oriented design ?
Computer architecture ?
Design patterns ?
All of this is easily within the reach of a self-taught programmer.Here 's my answer : self-taught programmers will not learn computability theory , complexity ( incl .
real analysis ) , classical algorithms/data structures , discrete math , combinatorics or numerical methods .
Other than that , a self-taught programmer will probably be much better at the purely mechanical part .</tokentext>
<sentencetext>There's way too much emphasis on Software Engineering in these comments.
Multithreading? Self-taught programmers are the only people who ever have the time to study IA-32 and associated errata to the point where they're able to write a reliable threading library.
Object-oriented design?
Computer architecture?
Design patterns?
All of this is easily within the reach of a self-taught programmer.Here's my answer: self-taught programmers will not learn computability theory, complexity (incl.
real analysis), classical algorithms/data structures, discrete math, combinatorics or numerical methods.
Other than that, a self-taught programmer will probably be much better at the purely mechanical part.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31208560</id>
	<title>Often lack the science</title>
	<author>Anonymous</author>
	<datestamp>1266656460000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>To properly design a complex computer system, you need to know the science behind it: discrete mathematics, logic etc.<br>Most self-taught figure out the necessary craft, such as design patterns, but they often lack the science.</p></htmltext>
<tokenext>To properly design a complex computer system , you need to know the science behind it : discrete mathematics , logic etc.Most self-taught figure out the necessary craft , such as design patterns , but they often lack the science .</tokentext>
<sentencetext>To properly design a complex computer system, you need to know the science behind it: discrete mathematics, logic etc.Most self-taught figure out the necessary craft, such as design patterns, but they often lack the science.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31204216</id>
	<title>I made the same journey</title>
	<author>James Youngman</author>
	<datestamp>1266574440000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>My list:</p><p>- complexity theory (and some 'concrete' mathematics)<br>- functional programming<br>- lisp<br>- domain specific language design<br>- concurrent systems design and implementation<br>- graph algorithms<br>- large-scale OO design (i.e. how to design a framework rather than a program)<br>- DFAs</p><p>That's after I eliminated the things I already knew I didn't understand when I graduated in 1993 (language parsing, compiler design and implementation, database theory, unit testing,<nobr> <wbr></nobr>...).</p></htmltext>
<tokenext>My list : - complexity theory ( and some 'concrete ' mathematics ) - functional programming- lisp- domain specific language design- concurrent systems design and implementation- graph algorithms- large-scale OO design ( i.e .
how to design a framework rather than a program ) - DFAsThat 's after I eliminated the things I already knew I did n't understand when I graduated in 1993 ( language parsing , compiler design and implementation , database theory , unit testing , ... ) .</tokentext>
<sentencetext>My list:- complexity theory (and some 'concrete' mathematics)- functional programming- lisp- domain specific language design- concurrent systems design and implementation- graph algorithms- large-scale OO design (i.e.
how to design a framework rather than a program)- DFAsThat's after I eliminated the things I already knew I didn't understand when I graduated in 1993 (language parsing, compiler design and implementation, database theory, unit testing, ...).</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199664</id>
	<title>Practice practice practice...</title>
	<author>xkrebstarx</author>
	<datestamp>1266597120000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>What did you miss in school... practice.

A student's full time job, for 4 years, is to practice CS technique and theory. That's it. Mystery solved.</htmltext>
<tokenext>What did you miss in school... practice . A student 's full time job , for 4 years , is to practice CS technique and theory .
That 's it .
Mystery solved .</tokentext>
<sentencetext>What did you miss in school... practice.

A student's full time job, for 4 years, is to practice CS technique and theory.
That's it.
Mystery solved.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200524</id>
	<title>Multiple axis</title>
	<author>Anonymous</author>
	<datestamp>1266600720000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>There is a confounding variable in this which is the level of expertise needed for a particular job.  A programmer doesn't need a degree.  Someone that just writes code doesn't need advanced knowledge.  Developers need some experience and knowledge.  Software Engineers need a higher level of experience and knowledge.  Even more so for Software Architects.  In essence, the self taught programmer isn't missing anything.  They know what they need to know.  The self taught Software Architect is a whole other story.  At this last level, it's important to be able to envision how you want a whole system to work, how others might want it to work, figure out which algorithms are important, what qualities it should possess, which patterns and anti-patterns are the solutions toward your goals, be able to re-envision an entire sub system and how it works to best fit your goals as various test implementations fail, how to combine problems to find a more universal solution, how to break down a problem to define the various different pieces of what you're dealing with, etc.</p><p>This all assumes the knowledge of Patterns, Anti-patterns, Algorithms, Data structures, OO, Threading, Computability, Automata, Language design, Usability, Business &amp; Risk Management, and computer architecture (etc, etc) to have in your tool set to solve the problems of designing and coding a system.  Gaining the knowledge of this tool set is very hard without formal training.  The ability to think logically about these problems is also enhanced by the knowledge and experience of having to think about these things.</p></htmltext>
<tokenext>There is a confounding variable in this which is the level of expertise needed for a particular job .
A programmer does n't need a degree .
Someone that just writes code does n't need advanced knowledge .
Developers need some experience and knowledge .
Software Engineers need a higher level of experience and knowledge .
Even more so for Software Architects .
In essence , the self taught programmer is n't missing anything .
They know what they need to know .
The self taught Software Architect is a whole other story .
At this last level , it 's important to be able to envision how you want a whole system to work , how others might want it to work , figure out which algorithms are important , what qualities it should possess , which patterns and anti-patterns are the solutions toward your goals , be able to re-envision an entire sub system and how it works to best fit your goals as various test implementations fail , how to combine problems to find a more universal solution , how to break down a problem to define the various different pieces of what you 're dealing with , etc.This all assumes the knowledge of Patterns , Anti-patterns , Algorithms , Data structures , OO , Threading , Computability , Automata , Language design , Usability , Business &amp; Risk Management , and computer architecture ( etc , etc ) to have in your tool set to solve the problems of designing and coding a system .
Gaining the knowledge of this tool set is very hard without formal training .
The ability to think logically about these problems is also enhanced by the knowledge and experience of having to think about these things .</tokentext>
<sentencetext>There is a confounding variable in this which is the level of expertise needed for a particular job.
A programmer doesn't need a degree.
Someone that just writes code doesn't need advanced knowledge.
Developers need some experience and knowledge.
Software Engineers need a higher level of experience and knowledge.
Even more so for Software Architects.
In essence, the self taught programmer isn't missing anything.
They know what they need to know.
The self taught Software Architect is a whole other story.
At this last level, it's important to be able to envision how you want a whole system to work, how others might want it to work, figure out which algorithms are important, what qualities it should possess, which patterns and anti-patterns are the solutions toward your goals, be able to re-envision an entire sub system and how it works to best fit your goals as various test implementations fail, how to combine problems to find a more universal solution, how to break down a problem to define the various different pieces of what you're dealing with, etc.This all assumes the knowledge of Patterns, Anti-patterns, Algorithms, Data structures, OO, Threading, Computability, Automata, Language design, Usability, Business &amp; Risk Management, and computer architecture (etc, etc) to have in your tool set to solve the problems of designing and coding a system.
Gaining the knowledge of this tool set is very hard without formal training.
The ability to think logically about these problems is also enhanced by the knowledge and experience of having to think about these things.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31271474</id>
	<title>formal = (a) re-use, (b) big picture</title>
	<author>MessyBlob</author>
	<datestamp>1267109820000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Formally-schooled programmers tend to think 'bigger-picture' and code for wider issues, whereas self-taught take pleasure in the engineering, will adopt minimalist solutions and tend to re-invent the wheel in fragments (as opposed to methods from a large library). As such, the self-taught solutions are likely to be more 'magical' and innovative - not necessarily good for deployment, but could be useful for prototyping and proof-of-concept.</htmltext>
<tokenext>Formally-schooled programmers tend to think 'bigger-picture ' and code for wider issues , whereas self-taught take pleasure in the engineering , will adopt minimalist solutions and tend to re-invent the wheel in fragments ( as opposed to methods from a large library ) .
As such , the self-taught solutions are likely to be more 'magical ' and innovative - not necessarily good for deployment , but could be useful for prototyping and proof-of-concept .</tokentext>
<sentencetext>Formally-schooled programmers tend to think 'bigger-picture' and code for wider issues, whereas self-taught take pleasure in the engineering, will adopt minimalist solutions and tend to re-invent the wheel in fragments (as opposed to methods from a large library).
As such, the self-taught solutions are likely to be more 'magical' and innovative - not necessarily good for deployment, but could be useful for prototyping and proof-of-concept.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199688</id>
	<title>Re:Self-taught too.</title>
	<author>Anonymous</author>
	<datestamp>1266597240000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>two things overlooked are computational complexity and standard algorithms. true, those are seldom used in the real world, but understanding them provides lots of insight when designing bigger systems, even when you're not actually using complex algorithms or calculating the performance of every row of code.<br><br>Most of the botched implementation of pagination/lazy loading of data come from the lacking of this knowledge. Most performance problem comes from "stuff A works" and if I need to do a lot of A operation I just put them in a loop, without thinking of what the common part of task A are and how those could be not looped - one example would be to display a table with a drop down for selecting colors, fetching the color list from the database for every row even if it's the same for all of them (ok, this is something everyone could have avoided, but I see lot of similar albeit subtler cases).<br><br>also "security" is something that you usually couldn't "pick up as you go" but requires dedicated effort to learn. There are lots of self made "experts" that claims the weirdest thing as hashing the password before sending it to the backend.</htmltext>
<tokenext>two things overlooked are computational complexity and standard algorithms .
true , those are seldom used in the real world , but understanding them provides lots of insight when designing bigger systems , even when you 're not actually using complex algorithms or calculating the performance of every row of code.Most of the botched implementation of pagination/lazy loading of data come from the lacking of this knowledge .
Most performance problem comes from " stuff A works " and if I need to do a lot of A operation I just put them in a loop , without thinking of what the common part of task A are and how those could be not looped - one example would be to display a table with a drop down for selecting colors , fetching the color list from the database for every row even if it 's the same for all of them ( ok , this is something everyone could have avoided , but I see lot of similar albeit subtler cases ) .also " security " is something that you usually could n't " pick up as you go " but requires dedicated effort to learn .
There are lots of self made " experts " that claims the weirdest thing as hashing the password before sending it to the backend .</tokentext>
<sentencetext>two things overlooked are computational complexity and standard algorithms.
true, those are seldom used in the real world, but understanding them provides lots of insight when designing bigger systems, even when you're not actually using complex algorithms or calculating the performance of every row of code.Most of the botched implementation of pagination/lazy loading of data come from the lacking of this knowledge.
Most performance problem comes from "stuff A works" and if I need to do a lot of A operation I just put them in a loop, without thinking of what the common part of task A are and how those could be not looped - one example would be to display a table with a drop down for selecting colors, fetching the color list from the database for every row even if it's the same for all of them (ok, this is something everyone could have avoided, but I see lot of similar albeit subtler cases).also "security" is something that you usually couldn't "pick up as you go" but requires dedicated effort to learn.
There are lots of self made "experts" that claims the weirdest thing as hashing the password before sending it to the backend.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199298</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199796</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>spirality</author>
	<datestamp>1266597720000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Yeah, these are the things that simply "programming" won't teach you. Not that you couldn't learn these things yourself.</p><p>As a practicing software engineer, I think my limited knowledge of computer architecture has proven quite valuable over the years.</p><p>Also agreed on theory. Having the ability to identify NP Complete problems is useful.</p><p>I would add the following to your list:</p><p>Basic Operating System Design, although you do encompass that in some of your other categories - threading, architecture</p><p>Functional Programming: Scheme, LISP, ML, etc... Most people who are "just programmers" don't learn such languages and thus don't typically think functionally, which can be useful when solving some problems. Sadly many computer science programs don't even teach this.</p><p>Math Generally: calculus, linear algebra, statistics, combinatorics, logic</p></htmltext>
<tokenext>Yeah , these are the things that simply " programming " wo n't teach you .
Not that you could n't learn these things yourself.As a practicing software engineer , I think my limited knowledge of computer architecture has proven quite valuable over the years.Also agreed on theory .
Having the ability to identify NP Complete problems is useful.I would add the following to your list : Basic Operating System Design , although you do encompass that in some of your other categories - threading , architectureFunctional Programming : Scheme , LISP , ML , etc... Most people who are " just programmers " do n't learn such languages and thus do n't typically think functionally , which can be useful when solving some problems .
Sadly many computer science programs do n't even teach this.Math Generally : calculus , linear algebra , statistics , combinatorics , logic</tokentext>
<sentencetext>Yeah, these are the things that simply "programming" won't teach you.
Not that you couldn't learn these things yourself.As a practicing software engineer, I think my limited knowledge of computer architecture has proven quite valuable over the years.Also agreed on theory.
Having the ability to identify NP Complete problems is useful.I would add the following to your list:Basic Operating System Design, although you do encompass that in some of your other categories - threading, architectureFunctional Programming: Scheme, LISP, ML, etc... Most people who are "just programmers" don't learn such languages and thus don't typically think functionally, which can be useful when solving some problems.
Sadly many computer science programs don't even teach this.Math Generally: calculus, linear algebra, statistics, combinatorics, logic</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31226998</id>
	<title>Try Dijkstra or Hofstadter</title>
	<author>jastram</author>
	<datestamp>1266831180000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I consider the basic crucial, as they provide a solid foundation.  Along those lines, I found <a href="http://en.wikipedia.org/wiki/G\%C3\%B6del,\_Escher,\_Bach" title="wikipedia.org" rel="nofollow">G&#246;del Escher Bach</a> [wikipedia.org] extremely useful and entertaining to read at the same time (mind you, it's not an easy read).  In the book, Hofestadter develops some simple programming languages and talks a lot about the properties of formal systems.<p>
Another excellent read is <a href="http://en.wikipedia.org/wiki/List\_of\_important\_publications\_in\_theoretical\_computer\_science#A\_Discipline\_of\_Programming" title="wikipedia.org" rel="nofollow">A Discipline of Programming</a> [wikipedia.org] (Dijkstra), which goes to the core of the issues in programming.</p><p>
In fact, the above <a href="http://en.wikipedia.org/wiki/List\_of\_important\_publications\_in\_theoretical\_computer\_science" title="wikipedia.org" rel="nofollow">List on Wikipedia</a> [wikipedia.org] may give you some more ideas.</p></htmltext>
<tokenext>I consider the basic crucial , as they provide a solid foundation .
Along those lines , I found G   del Escher Bach [ wikipedia.org ] extremely useful and entertaining to read at the same time ( mind you , it 's not an easy read ) .
In the book , Hofestadter develops some simple programming languages and talks a lot about the properties of formal systems .
Another excellent read is A Discipline of Programming [ wikipedia.org ] ( Dijkstra ) , which goes to the core of the issues in programming .
In fact , the above List on Wikipedia [ wikipedia.org ] may give you some more ideas .</tokentext>
<sentencetext>I consider the basic crucial, as they provide a solid foundation.
Along those lines, I found Gödel Escher Bach [wikipedia.org] extremely useful and entertaining to read at the same time (mind you, it's not an easy read).
In the book, Hofestadter develops some simple programming languages and talks a lot about the properties of formal systems.
Another excellent read is A Discipline of Programming [wikipedia.org] (Dijkstra), which goes to the core of the issues in programming.
In fact, the above List on Wikipedia [wikipedia.org] may give you some more ideas.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200718</id>
	<title>Both Self-Taught and School-Taught Have Gaps</title>
	<author>Phleg</author>
	<datestamp>1266601620000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Both self-taught programmers and school-taught programmers have gaps. I feel like I got pretty good exposure to both scenarios, since I was self-taught but did go to college, where I had some of those gaps filled in (and also took plenty of courses where I learned precious little).</p><p>Some things that self-taught programmers often lack are,
  </p><ul>
    <li>an intuitive notion of algorithm running-time (i.e., big-O)</li><li>design patterns, and how to create <em>new</em> ones.</li></ul><p>
There's others (compiler theory, AI, whatever), but in practical software development those are the two that come up most often. But I find that self-taught programmers are often better at what they do than school-educated ones, because they are sensitive to the gaps they have, and they know how to learn things on their own.</p><p>School-taught programmers on the other hand have far, far more gaps in my experience. They often lack
  </p><ul>
    <li>understanding of and experience with version control</li><li>the ability to write software for <em>others</em> to use or maintain</li><li>the ability to teach themselves new languages or tools.</li></ul><p>In my opinion the main problems with current Computer Science curricula are that the professors themselves are heavily isolated from real-world application development. Courses on version control (especially newer tools like git or mercurial as opposed to CVS) are virtually nonexistent. Courses that teach students how to structure code for others to use (ex., writing code as a library for others to link against) don't exist. Because Computer Science courses are isolated from real-world needs like maintenance and working with others, the only criteria students' code is judged on is whether or not it produces correct output.</p><p>Students learn one or two languages, but virtually always languages that share roughly the same syntax (e.g., C++ and Java). Very little time is spent on highly-productive scripting languages like Ruby, JavaScript, or Python. And students are never taught to adapt their solutions to the strengths of different languages. If they learn Java first, every program they write will try to solve it the "Java way". Not to pick on Java &mdash; the point is simply that nobody is taught to <em>identify and use</em> the strengths of languages, or learn their common idioms, so they just write everything like it's their Language of Choice.</p></htmltext>
<tokenext>Both self-taught programmers and school-taught programmers have gaps .
I feel like I got pretty good exposure to both scenarios , since I was self-taught but did go to college , where I had some of those gaps filled in ( and also took plenty of courses where I learned precious little ) .Some things that self-taught programmers often lack are , an intuitive notion of algorithm running-time ( i.e. , big-O ) design patterns , and how to create new ones .
There 's others ( compiler theory , AI , whatever ) , but in practical software development those are the two that come up most often .
But I find that self-taught programmers are often better at what they do than school-educated ones , because they are sensitive to the gaps they have , and they know how to learn things on their own.School-taught programmers on the other hand have far , far more gaps in my experience .
They often lack understanding of and experience with version controlthe ability to write software for others to use or maintainthe ability to teach themselves new languages or tools.In my opinion the main problems with current Computer Science curricula are that the professors themselves are heavily isolated from real-world application development .
Courses on version control ( especially newer tools like git or mercurial as opposed to CVS ) are virtually nonexistent .
Courses that teach students how to structure code for others to use ( ex. , writing code as a library for others to link against ) do n't exist .
Because Computer Science courses are isolated from real-world needs like maintenance and working with others , the only criteria students ' code is judged on is whether or not it produces correct output.Students learn one or two languages , but virtually always languages that share roughly the same syntax ( e.g. , C + + and Java ) .
Very little time is spent on highly-productive scripting languages like Ruby , JavaScript , or Python .
And students are never taught to adapt their solutions to the strengths of different languages .
If they learn Java first , every program they write will try to solve it the " Java way " .
Not to pick on Java    the point is simply that nobody is taught to identify and use the strengths of languages , or learn their common idioms , so they just write everything like it 's their Language of Choice .</tokentext>
<sentencetext>Both self-taught programmers and school-taught programmers have gaps.
I feel like I got pretty good exposure to both scenarios, since I was self-taught but did go to college, where I had some of those gaps filled in (and also took plenty of courses where I learned precious little).Some things that self-taught programmers often lack are,
  
    an intuitive notion of algorithm running-time (i.e., big-O)design patterns, and how to create new ones.
There's others (compiler theory, AI, whatever), but in practical software development those are the two that come up most often.
But I find that self-taught programmers are often better at what they do than school-educated ones, because they are sensitive to the gaps they have, and they know how to learn things on their own.School-taught programmers on the other hand have far, far more gaps in my experience.
They often lack
  
    understanding of and experience with version controlthe ability to write software for others to use or maintainthe ability to teach themselves new languages or tools.In my opinion the main problems with current Computer Science curricula are that the professors themselves are heavily isolated from real-world application development.
Courses on version control (especially newer tools like git or mercurial as opposed to CVS) are virtually nonexistent.
Courses that teach students how to structure code for others to use (ex., writing code as a library for others to link against) don't exist.
Because Computer Science courses are isolated from real-world needs like maintenance and working with others, the only criteria students' code is judged on is whether or not it produces correct output.Students learn one or two languages, but virtually always languages that share roughly the same syntax (e.g., C++ and Java).
Very little time is spent on highly-productive scripting languages like Ruby, JavaScript, or Python.
And students are never taught to adapt their solutions to the strengths of different languages.
If they learn Java first, every program they write will try to solve it the "Java way".
Not to pick on Java — the point is simply that nobody is taught to identify and use the strengths of languages, or learn their common idioms, so they just write everything like it's their Language of Choice.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200792</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>phallstrom</author>
	<datestamp>1266601920000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Not understanding the business reasons behind the decisions being made.   The PHB's don't care what language you use or algorithm or any of that (usually).  What they do care about is that it's on time, has the features they want, and gives them a high return on investment.</p><p>I've sat in meetings were a programmer will go on about why a certain feature can't/shouldn't be done for a variety of technical reasons and gets no where.  And right after that another programmer will mention that the feature can't be done as it would cost $$$ and delay the project and not provide any ROI.  And the feature is canceled.</p><p>And, no, I'm not suggesting programmers should pull the ROI trick out of the bag when they don't want to do something, but if you want to convince management, speak their language.</p></htmltext>
<tokenext>Not understanding the business reasons behind the decisions being made .
The PHB 's do n't care what language you use or algorithm or any of that ( usually ) .
What they do care about is that it 's on time , has the features they want , and gives them a high return on investment.I 've sat in meetings were a programmer will go on about why a certain feature ca n't/should n't be done for a variety of technical reasons and gets no where .
And right after that another programmer will mention that the feature ca n't be done as it would cost $ $ $ and delay the project and not provide any ROI .
And the feature is canceled.And , no , I 'm not suggesting programmers should pull the ROI trick out of the bag when they do n't want to do something , but if you want to convince management , speak their language .</tokentext>
<sentencetext>Not understanding the business reasons behind the decisions being made.
The PHB's don't care what language you use or algorithm or any of that (usually).
What they do care about is that it's on time, has the features they want, and gives them a high return on investment.I've sat in meetings were a programmer will go on about why a certain feature can't/shouldn't be done for a variety of technical reasons and gets no where.
And right after that another programmer will mention that the feature can't be done as it would cost $$$ and delay the project and not provide any ROI.
And the feature is canceled.And, no, I'm not suggesting programmers should pull the ROI trick out of the bag when they don't want to do something, but if you want to convince management, speak their language.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31209698</id>
	<title>What Knowledge Gaps Do Self-Taught Programmers G..</title>
	<author>stuckinphp</author>
	<datestamp>1266676980000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>What Knowledge Gaps Do Self-Taught Programmers Generally Have?</p><p>The same ones us taught programmers have. The ones we need and haven't learned yet.</p></htmltext>
<tokenext>What Knowledge Gaps Do Self-Taught Programmers Generally Have ? The same ones us taught programmers have .
The ones we need and have n't learned yet .</tokentext>
<sentencetext>What Knowledge Gaps Do Self-Taught Programmers Generally Have?The same ones us taught programmers have.
The ones we need and haven't learned yet.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202068</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>Anonymous</author>
	<datestamp>1266608220000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Schooled programmers != programmers just out of school. The problems you indicate are endemic to all inexperienced young employees, but that's not what we're discussing here...</p></htmltext>
<tokenext>Schooled programmers ! = programmers just out of school .
The problems you indicate are endemic to all inexperienced young employees , but that 's not what we 're discussing here.. .</tokentext>
<sentencetext>Schooled programmers != programmers just out of school.
The problems you indicate are endemic to all inexperienced young employees, but that's not what we're discussing here...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200212</id>
	<title>physicicts and code...</title>
	<author>Anonymous</author>
	<datestamp>1266599580000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Wel many maths and physics people cross over to become programmers. Especialy in firms that work in a mathamatical of physical feild.</p><p>I have worked in a mining software firm that did this and can offer some insight. I have also taught tertiary students so I know roughly where the imprtant gaps are.</p><p>Firstly in terms of code quality.<br>-you may lack of expose to maintaining software and be acusted to math using single letter variables. The absolute importance of descriptive variable names for any thing not self explanitory (i, x, y) is often lost.<br>Other code quality issues like use of comments ect have not been forced in by experince.</p><p>Remember always that you are probably going to code complicated things on a subject matter that the rest of the programming staff only have a general knolede in. But it falls to the rest of the staff to maintain and debug your code. You must write all physics code with that in mind.</p><p>I found that a lot of code writend by non-programmer expers is very costly and difficult to maintain.</p><p>You may find that some pure comp sci stuff is missing. Can you do predicate calculus? work in lisp, train neural networks, optimise evolutionary algorithems, optimise code using a vast array of obscure data structurs.<br>Probably not. But most of the industry jobs don't require this.</p><p>Important knowledge gaps may also exist in code related sujects. Database design and SQL are a artform that self taught programmers will generaly not tough because it is not interesting. But it is important in the workforce.</p><p>Beyond that a tertiary education only deos so much. Time spent programming and industry experience will improve your code more than reading a few undergraduate level books.<br>The true strengh up a comp sci degre is often the amount of free time students have t  practice programming.</p><p>Hope this helps.</p></htmltext>
<tokenext>Wel many maths and physics people cross over to become programmers .
Especialy in firms that work in a mathamatical of physical feild.I have worked in a mining software firm that did this and can offer some insight .
I have also taught tertiary students so I know roughly where the imprtant gaps are.Firstly in terms of code quality.-you may lack of expose to maintaining software and be acusted to math using single letter variables .
The absolute importance of descriptive variable names for any thing not self explanitory ( i , x , y ) is often lost.Other code quality issues like use of comments ect have not been forced in by experince.Remember always that you are probably going to code complicated things on a subject matter that the rest of the programming staff only have a general knolede in .
But it falls to the rest of the staff to maintain and debug your code .
You must write all physics code with that in mind.I found that a lot of code writend by non-programmer expers is very costly and difficult to maintain.You may find that some pure comp sci stuff is missing .
Can you do predicate calculus ?
work in lisp , train neural networks , optimise evolutionary algorithems , optimise code using a vast array of obscure data structurs.Probably not .
But most of the industry jobs do n't require this.Important knowledge gaps may also exist in code related sujects .
Database design and SQL are a artform that self taught programmers will generaly not tough because it is not interesting .
But it is important in the workforce.Beyond that a tertiary education only deos so much .
Time spent programming and industry experience will improve your code more than reading a few undergraduate level books.The true strengh up a comp sci degre is often the amount of free time students have t practice programming.Hope this helps .</tokentext>
<sentencetext>Wel many maths and physics people cross over to become programmers.
Especialy in firms that work in a mathamatical of physical feild.I have worked in a mining software firm that did this and can offer some insight.
I have also taught tertiary students so I know roughly where the imprtant gaps are.Firstly in terms of code quality.-you may lack of expose to maintaining software and be acusted to math using single letter variables.
The absolute importance of descriptive variable names for any thing not self explanitory (i, x, y) is often lost.Other code quality issues like use of comments ect have not been forced in by experince.Remember always that you are probably going to code complicated things on a subject matter that the rest of the programming staff only have a general knolede in.
But it falls to the rest of the staff to maintain and debug your code.
You must write all physics code with that in mind.I found that a lot of code writend by non-programmer expers is very costly and difficult to maintain.You may find that some pure comp sci stuff is missing.
Can you do predicate calculus?
work in lisp, train neural networks, optimise evolutionary algorithems, optimise code using a vast array of obscure data structurs.Probably not.
But most of the industry jobs don't require this.Important knowledge gaps may also exist in code related sujects.
Database design and SQL are a artform that self taught programmers will generaly not tough because it is not interesting.
But it is important in the workforce.Beyond that a tertiary education only deos so much.
Time spent programming and industry experience will improve your code more than reading a few undergraduate level books.The true strengh up a comp sci degre is often the amount of free time students have t  practice programming.Hope this helps.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31205872</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>CodeBuster</author>
	<datestamp>1266582420000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext>I have BS in Information and Computer Science and I must say that my experience was remarkably similar to the parent's. One problem, IMHO, is that the major is called "computer science" when it should really be called "computational science" instead. People assume that the degree is all about computers and their use but this is a misnomer. It is more correct to say that "computer science" is a specialized study of mathematics as it relates to computation and its complexity with some practical high level computer engineering concepts thrown into the bargain; computers are merely the tools that we use to investigate the theories in practice. Almost everything that I actually use in my day to day software engineering jobs was learned <i>after</i> graduation through working. IMHO, It would do a better service, both to students and industry, if universities would break up the curriculum so that software engineering, "computer science", and computer engineering were more clearly distinct majors. There would be commonalities of course, particularly in the lower division courses, but right now too many students go into "computer science" without really understanding what they are getting themselves into before they have almost enough courses to minor.</htmltext>
<tokenext>I have BS in Information and Computer Science and I must say that my experience was remarkably similar to the parent 's .
One problem , IMHO , is that the major is called " computer science " when it should really be called " computational science " instead .
People assume that the degree is all about computers and their use but this is a misnomer .
It is more correct to say that " computer science " is a specialized study of mathematics as it relates to computation and its complexity with some practical high level computer engineering concepts thrown into the bargain ; computers are merely the tools that we use to investigate the theories in practice .
Almost everything that I actually use in my day to day software engineering jobs was learned after graduation through working .
IMHO , It would do a better service , both to students and industry , if universities would break up the curriculum so that software engineering , " computer science " , and computer engineering were more clearly distinct majors .
There would be commonalities of course , particularly in the lower division courses , but right now too many students go into " computer science " without really understanding what they are getting themselves into before they have almost enough courses to minor .</tokentext>
<sentencetext>I have BS in Information and Computer Science and I must say that my experience was remarkably similar to the parent's.
One problem, IMHO, is that the major is called "computer science" when it should really be called "computational science" instead.
People assume that the degree is all about computers and their use but this is a misnomer.
It is more correct to say that "computer science" is a specialized study of mathematics as it relates to computation and its complexity with some practical high level computer engineering concepts thrown into the bargain; computers are merely the tools that we use to investigate the theories in practice.
Almost everything that I actually use in my day to day software engineering jobs was learned after graduation through working.
IMHO, It would do a better service, both to students and industry, if universities would break up the curriculum so that software engineering, "computer science", and computer engineering were more clearly distinct majors.
There would be commonalities of course, particularly in the lower division courses, but right now too many students go into "computer science" without really understanding what they are getting themselves into before they have almost enough courses to minor.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200134</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200568</id>
	<title>foundations and attitude</title>
	<author>plcurechax</author>
	<datestamp>1266600900000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>In my experience the biggest problems are <b>caused</b> by self-taught programmers who lack the humility to realize that computer science and computing a large field, in which they are not domain experts of all of it. Seriously, I'm saying this not to be an insult, but as a plea for self-taught programmers to take their blinders off, and admit to themselves there is a lot of knowledge about computer science and computing (or IT), which has a rich if relatively short history. The ones who get pass the chip-on-their-shoulder defense often become very good to great programmers. The ones who don't tend to become isolated, confrontational, unable to handle constructive feedback or criticism, and tend to be poor team players.</p><p>The other big weakness they <i>can</i> have, is they seem more apt to have problem with NIH-syndrome (not invented here). Anything they didn't do or create is crap. Again this seems to be a self-defense mechanism gone astray.</p><p>If these two psychological factors are dealt with, the technical knowledge gaps are in comparison trivial to deal with.</p><p>In your case, exposure to higher education including post secondary mathematics, helps with the building the experience of abstract thinking which is a excellent trait or training for programmers, to deal with programming in both the concrete and abstract terms.</p><p>A programmer who knows and understands the fundamentals of computer science, including data structures, algorithms, number systems, boolean logic, at least a basic understanding of computer architecture in my experience tends to be more flexible and adaptable to change in computing / IT in general as well as able to less stressful to change development environments including languages. <a href="http://mitpress.mit.edu/sicp/" title="mit.edu">Structure and Interpretation of Computer Programs</a> [mit.edu], <a href="http://www.pearsonhighered.com/educator/academic/product/0,,0131485210,00\%2Ben-USS\_01DBC.html" title="pearsonhighered.com">Structured Computer Organization</a> [pearsonhighered.com], and <a href="http://mitpress.mit.edu/catalog/item/default.asp?ttype=2&amp;tid=11866" title="mit.edu">Introduction to Algorithms</a> [mit.edu] are excellent resources for any self-taught programmer looking to fill gaps in the knowledge.</p><p>Also professional computing / IT society memberships might be worth considering (especially if your employer will pick up the tab), for example the <a href="http://www.acm.org/" title="acm.org">ACM</a> [acm.org], and the IEEE <a href="http://www.computer.org/" title="computer.org">Computer Society</a> [computer.org]. Both have a bent towards academia, but they largely due to the self-interest of authors in academia to publish (for their own career success), as opposed to a conscience focus away from the "real-world" programming in the trenches.</p><p>For any new professional programmer, texts like The Pragmatic Programmer, Code Complete, Peopleware, and The Mythical Man-Month are strongly recommended reading matieral.</p></htmltext>
<tokenext>In my experience the biggest problems are caused by self-taught programmers who lack the humility to realize that computer science and computing a large field , in which they are not domain experts of all of it .
Seriously , I 'm saying this not to be an insult , but as a plea for self-taught programmers to take their blinders off , and admit to themselves there is a lot of knowledge about computer science and computing ( or IT ) , which has a rich if relatively short history .
The ones who get pass the chip-on-their-shoulder defense often become very good to great programmers .
The ones who do n't tend to become isolated , confrontational , unable to handle constructive feedback or criticism , and tend to be poor team players.The other big weakness they can have , is they seem more apt to have problem with NIH-syndrome ( not invented here ) .
Anything they did n't do or create is crap .
Again this seems to be a self-defense mechanism gone astray.If these two psychological factors are dealt with , the technical knowledge gaps are in comparison trivial to deal with.In your case , exposure to higher education including post secondary mathematics , helps with the building the experience of abstract thinking which is a excellent trait or training for programmers , to deal with programming in both the concrete and abstract terms.A programmer who knows and understands the fundamentals of computer science , including data structures , algorithms , number systems , boolean logic , at least a basic understanding of computer architecture in my experience tends to be more flexible and adaptable to change in computing / IT in general as well as able to less stressful to change development environments including languages .
Structure and Interpretation of Computer Programs [ mit.edu ] , Structured Computer Organization [ pearsonhighered.com ] , and Introduction to Algorithms [ mit.edu ] are excellent resources for any self-taught programmer looking to fill gaps in the knowledge.Also professional computing / IT society memberships might be worth considering ( especially if your employer will pick up the tab ) , for example the ACM [ acm.org ] , and the IEEE Computer Society [ computer.org ] .
Both have a bent towards academia , but they largely due to the self-interest of authors in academia to publish ( for their own career success ) , as opposed to a conscience focus away from the " real-world " programming in the trenches.For any new professional programmer , texts like The Pragmatic Programmer , Code Complete , Peopleware , and The Mythical Man-Month are strongly recommended reading matieral .</tokentext>
<sentencetext>In my experience the biggest problems are caused by self-taught programmers who lack the humility to realize that computer science and computing a large field, in which they are not domain experts of all of it.
Seriously, I'm saying this not to be an insult, but as a plea for self-taught programmers to take their blinders off, and admit to themselves there is a lot of knowledge about computer science and computing (or IT), which has a rich if relatively short history.
The ones who get pass the chip-on-their-shoulder defense often become very good to great programmers.
The ones who don't tend to become isolated, confrontational, unable to handle constructive feedback or criticism, and tend to be poor team players.The other big weakness they can have, is they seem more apt to have problem with NIH-syndrome (not invented here).
Anything they didn't do or create is crap.
Again this seems to be a self-defense mechanism gone astray.If these two psychological factors are dealt with, the technical knowledge gaps are in comparison trivial to deal with.In your case, exposure to higher education including post secondary mathematics, helps with the building the experience of abstract thinking which is a excellent trait or training for programmers, to deal with programming in both the concrete and abstract terms.A programmer who knows and understands the fundamentals of computer science, including data structures, algorithms, number systems, boolean logic, at least a basic understanding of computer architecture in my experience tends to be more flexible and adaptable to change in computing / IT in general as well as able to less stressful to change development environments including languages.
Structure and Interpretation of Computer Programs [mit.edu], Structured Computer Organization [pearsonhighered.com], and Introduction to Algorithms [mit.edu] are excellent resources for any self-taught programmer looking to fill gaps in the knowledge.Also professional computing / IT society memberships might be worth considering (especially if your employer will pick up the tab), for example the ACM [acm.org], and the IEEE Computer Society [computer.org].
Both have a bent towards academia, but they largely due to the self-interest of authors in academia to publish (for their own career success), as opposed to a conscience focus away from the "real-world" programming in the trenches.For any new professional programmer, texts like The Pragmatic Programmer, Code Complete, Peopleware, and The Mythical Man-Month are strongly recommended reading matieral.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200620</id>
	<title>SQL, SQL and more SQL</title>
	<author>Neeperando</author>
	<datestamp>1266601200000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I am about half self-taught and half college-taught. I am currently looking for jobs, and despite having 10 years programming experience and knowing more than a handful of languages, understanding OO and algorithms, I don't have the minimum requirements for most jobs I'm looking at. Why? I don't know SQL well. It's one thing if you're looking to work at a major, kickass place like Google or Microsoft, but a lot of the smaller shops are looking for people who can write client-server code in Java and SQL. If you don't have that, 80\% of the jobs on Monster are off the table.</htmltext>
<tokenext>I am about half self-taught and half college-taught .
I am currently looking for jobs , and despite having 10 years programming experience and knowing more than a handful of languages , understanding OO and algorithms , I do n't have the minimum requirements for most jobs I 'm looking at .
Why ? I do n't know SQL well .
It 's one thing if you 're looking to work at a major , kickass place like Google or Microsoft , but a lot of the smaller shops are looking for people who can write client-server code in Java and SQL .
If you do n't have that , 80 \ % of the jobs on Monster are off the table .</tokentext>
<sentencetext>I am about half self-taught and half college-taught.
I am currently looking for jobs, and despite having 10 years programming experience and knowing more than a handful of languages, understanding OO and algorithms, I don't have the minimum requirements for most jobs I'm looking at.
Why? I don't know SQL well.
It's one thing if you're looking to work at a major, kickass place like Google or Microsoft, but a lot of the smaller shops are looking for people who can write client-server code in Java and SQL.
If you don't have that, 80\% of the jobs on Monster are off the table.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31208976</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>metaforest</author>
	<datestamp>1266664560000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>One of the worst examples I can think of off the top of my head is LSL (Linden Scripting Language), used in Second Life. It's an absolute nightmare of a language. And yet, it made it into a large-scale product like Second Life.</p></div><p>If you have problems with LSL then you are misusing it.    It is a DSL and it's very good at what it was DESIGNED to do.  Which is animate CSG link-sets.   Using for anything else is asking way too much.  Even Linden Labs has forgotten that it's not a generalized language.  Abuses abound, including features added to the stdlib that should not be there without redesigning the language!</p><p>The crap that many people write in LSL is an example of trying to use a phillips screw driver to install every fucking fastener except phillips-head screws!!!</p><p>Programming in LSL has more in common with using an embedded micro-controller with an application specific library for motion control....</p><p>Working with LSL has been a kick.  One example is building very efficient PID controllers...   and other tasks that interact with virtually physical processes.</p><p>People that complain about LSL either don't get it, or are actively trying to make it operate in problem domains it was not designed to operate in.</p></div>
	</htmltext>
<tokenext>One of the worst examples I can think of off the top of my head is LSL ( Linden Scripting Language ) , used in Second Life .
It 's an absolute nightmare of a language .
And yet , it made it into a large-scale product like Second Life.If you have problems with LSL then you are misusing it .
It is a DSL and it 's very good at what it was DESIGNED to do .
Which is animate CSG link-sets .
Using for anything else is asking way too much .
Even Linden Labs has forgotten that it 's not a generalized language .
Abuses abound , including features added to the stdlib that should not be there without redesigning the language ! The crap that many people write in LSL is an example of trying to use a phillips screw driver to install every fucking fastener except phillips-head screws ! !
! Programming in LSL has more in common with using an embedded micro-controller with an application specific library for motion control....Working with LSL has been a kick .
One example is building very efficient PID controllers... and other tasks that interact with virtually physical processes.People that complain about LSL either do n't get it , or are actively trying to make it operate in problem domains it was not designed to operate in .</tokentext>
<sentencetext>One of the worst examples I can think of off the top of my head is LSL (Linden Scripting Language), used in Second Life.
It's an absolute nightmare of a language.
And yet, it made it into a large-scale product like Second Life.If you have problems with LSL then you are misusing it.
It is a DSL and it's very good at what it was DESIGNED to do.
Which is animate CSG link-sets.
Using for anything else is asking way too much.
Even Linden Labs has forgotten that it's not a generalized language.
Abuses abound, including features added to the stdlib that should not be there without redesigning the language!The crap that many people write in LSL is an example of trying to use a phillips screw driver to install every fucking fastener except phillips-head screws!!
!Programming in LSL has more in common with using an embedded micro-controller with an application specific library for motion control....Working with LSL has been a kick.
One example is building very efficient PID controllers...   and other tasks that interact with virtually physical processes.People that complain about LSL either don't get it, or are actively trying to make it operate in problem domains it was not designed to operate in.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203696</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200902</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>bdenton42</author>
	<datestamp>1266602580000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Generalizing... Self-taught usually means that the person has a technical interest in programming.   You're likely to find more of them to be competent as they've spent the time scouring the manuals to figure out how the thing works.  From there you have to find out what else they have... do they have good business fundamentals to understand how to apply programming to what you need for your business, or good math fundamentals if your need is complex scientific programming?</p><p>With Schooled you'll get some of the people as above who really have a technical interest in programming, but you also get a bunch of yahoos who are just there to learn enough about programming to get by and land a job. The former will be both good programmers and will have either a rudimentary business or mathmatical foundation taught to them as well.   The latter are probably more likely to end up in management...</p></htmltext>
<tokenext>Generalizing... Self-taught usually means that the person has a technical interest in programming .
You 're likely to find more of them to be competent as they 've spent the time scouring the manuals to figure out how the thing works .
From there you have to find out what else they have... do they have good business fundamentals to understand how to apply programming to what you need for your business , or good math fundamentals if your need is complex scientific programming ? With Schooled you 'll get some of the people as above who really have a technical interest in programming , but you also get a bunch of yahoos who are just there to learn enough about programming to get by and land a job .
The former will be both good programmers and will have either a rudimentary business or mathmatical foundation taught to them as well .
The latter are probably more likely to end up in management.. .</tokentext>
<sentencetext>Generalizing... Self-taught usually means that the person has a technical interest in programming.
You're likely to find more of them to be competent as they've spent the time scouring the manuals to figure out how the thing works.
From there you have to find out what else they have... do they have good business fundamentals to understand how to apply programming to what you need for your business, or good math fundamentals if your need is complex scientific programming?With Schooled you'll get some of the people as above who really have a technical interest in programming, but you also get a bunch of yahoos who are just there to learn enough about programming to get by and land a job.
The former will be both good programmers and will have either a rudimentary business or mathmatical foundation taught to them as well.
The latter are probably more likely to end up in management...</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200300</id>
	<title>Programming vs. Computer Science</title>
	<author>BadKneeDad</author>
	<datestamp>1266599940000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>As someone who was in exactly your position a few years back I might have some insight into this.</p><p>First off I have a BS in physics with a minor in Mathematics and my physics department was HEAVY into computational physics. My grad work is in a different field altogether! As an undergrad, we coded for almost every class after our intro courses but we were never required to take programming classes; most all of us were self taught. I had started to code on a Commodore as kid (self taught) so I was comfortable with programming, but programming is not computer science!</p><p>A few years back I took a position at a software company as a developer (still there, still coding, although now a little more senior) and my tech lead was a computer scientist (versus a programmer or engineer). I had the good fortune to work with him for a few years and I quickly learned that programming is not computer science.</p><p>As others have pointed out, you may have missed good OOP design (talked a lot about but rarely done), design patterns and big O notation (I had a numerical analysis course in college so I had seen that before); these are easy to learn as needed (e.g. The Art of Computer Programming, Google, etc.). Perhaps the biggest thing I had to learn was the whole development process; customer requirements, functional specifications, technical specifications, QA cycle, learning to do what is needed versus what is requested, defensive coding, future anticipation coding, etc. Another thing that you might be missing is a fundamental understanding of why a computer does what it does (e.g. why you shouldn&rsquo;t compare two doubles for equality, race conditions in parallel work, etc). Again, my physics program was computationally heavy so I covered some of this but your history may be different.</p><p>I&rsquo;d say that should cover what you&rsquo;d find you&rsquo;re missing (for your first 2-3 years as a professional at least). I might add to this the fact you under estimate how little new code you actually get to write; meetings, documents, technical support, design and maintenance take up a lot of your time (both low level and senior developers).</p><p>I think the biggest help was coming to terms with the famous quote &ldquo;Computer science is no more about computers than astronomy is about telescopes.&rdquo; (Edsger Dijkstra).</p></div>
	</htmltext>
<tokenext>As someone who was in exactly your position a few years back I might have some insight into this.First off I have a BS in physics with a minor in Mathematics and my physics department was HEAVY into computational physics .
My grad work is in a different field altogether !
As an undergrad , we coded for almost every class after our intro courses but we were never required to take programming classes ; most all of us were self taught .
I had started to code on a Commodore as kid ( self taught ) so I was comfortable with programming , but programming is not computer science ! A few years back I took a position at a software company as a developer ( still there , still coding , although now a little more senior ) and my tech lead was a computer scientist ( versus a programmer or engineer ) .
I had the good fortune to work with him for a few years and I quickly learned that programming is not computer science.As others have pointed out , you may have missed good OOP design ( talked a lot about but rarely done ) , design patterns and big O notation ( I had a numerical analysis course in college so I had seen that before ) ; these are easy to learn as needed ( e.g .
The Art of Computer Programming , Google , etc. ) .
Perhaps the biggest thing I had to learn was the whole development process ; customer requirements , functional specifications , technical specifications , QA cycle , learning to do what is needed versus what is requested , defensive coding , future anticipation coding , etc .
Another thing that you might be missing is a fundamental understanding of why a computer does what it does ( e.g .
why you shouldn    t compare two doubles for equality , race conditions in parallel work , etc ) .
Again , my physics program was computationally heavy so I covered some of this but your history may be different.I    d say that should cover what you    d find you    re missing ( for your first 2-3 years as a professional at least ) .
I might add to this the fact you under estimate how little new code you actually get to write ; meetings , documents , technical support , design and maintenance take up a lot of your time ( both low level and senior developers ) .I think the biggest help was coming to terms with the famous quote    Computer science is no more about computers than astronomy is about telescopes.    ( Edsger Dijkstra ) .</tokentext>
<sentencetext>As someone who was in exactly your position a few years back I might have some insight into this.First off I have a BS in physics with a minor in Mathematics and my physics department was HEAVY into computational physics.
My grad work is in a different field altogether!
As an undergrad, we coded for almost every class after our intro courses but we were never required to take programming classes; most all of us were self taught.
I had started to code on a Commodore as kid (self taught) so I was comfortable with programming, but programming is not computer science!A few years back I took a position at a software company as a developer (still there, still coding, although now a little more senior) and my tech lead was a computer scientist (versus a programmer or engineer).
I had the good fortune to work with him for a few years and I quickly learned that programming is not computer science.As others have pointed out, you may have missed good OOP design (talked a lot about but rarely done), design patterns and big O notation (I had a numerical analysis course in college so I had seen that before); these are easy to learn as needed (e.g.
The Art of Computer Programming, Google, etc.).
Perhaps the biggest thing I had to learn was the whole development process; customer requirements, functional specifications, technical specifications, QA cycle, learning to do what is needed versus what is requested, defensive coding, future anticipation coding, etc.
Another thing that you might be missing is a fundamental understanding of why a computer does what it does (e.g.
why you shouldn’t compare two doubles for equality, race conditions in parallel work, etc).
Again, my physics program was computationally heavy so I covered some of this but your history may be different.I’d say that should cover what you’d find you’re missing (for your first 2-3 years as a professional at least).
I might add to this the fact you under estimate how little new code you actually get to write; meetings, documents, technical support, design and maintenance take up a lot of your time (both low level and senior developers).I think the biggest help was coming to terms with the famous quote “Computer science is no more about computers than astronomy is about telescopes.” (Edsger Dijkstra).
	</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199768</id>
	<title>If you want to learn some compuational theory....</title>
	<author>spottedkangaroo</author>
	<datestamp>1266597540000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I highly recommend Lewis' Elemtns of the Theory of Computation.   Garey's Computers and Intractability seems to get quoted a lot as well.  I'm not sure how important this stuff is in every day computing, but if you want to learn computability, these two cover everything.</htmltext>
<tokenext>I highly recommend Lewis ' Elemtns of the Theory of Computation .
Garey 's Computers and Intractability seems to get quoted a lot as well .
I 'm not sure how important this stuff is in every day computing , but if you want to learn computability , these two cover everything .</tokentext>
<sentencetext>I highly recommend Lewis' Elemtns of the Theory of Computation.
Garey's Computers and Intractability seems to get quoted a lot as well.
I'm not sure how important this stuff is in every day computing, but if you want to learn computability, these two cover everything.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203464</id>
	<title>Definitely</title>
	<author>mbessey</author>
	<datestamp>1266571560000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Complexity analysis sometimes evades the college-educated, too, but it's a particular weakness among the self-taught programmers I have known. It's a little sad to see someone trying to micro-optimize the heck out of a very inefficient algorithm, when f they just used a BST or a hash table instead of a list, they'd have vastly better performance.</p></htmltext>
<tokenext>Complexity analysis sometimes evades the college-educated , too , but it 's a particular weakness among the self-taught programmers I have known .
It 's a little sad to see someone trying to micro-optimize the heck out of a very inefficient algorithm , when f they just used a BST or a hash table instead of a list , they 'd have vastly better performance .</tokentext>
<sentencetext>Complexity analysis sometimes evades the college-educated, too, but it's a particular weakness among the self-taught programmers I have known.
It's a little sad to see someone trying to micro-optimize the heck out of a very inefficient algorithm, when f they just used a BST or a hash table instead of a list, they'd have vastly better performance.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199790</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200402</id>
	<title>Find a mentor</title>
	<author>azadrozny</author>
	<datestamp>1266600300000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Don't overlook the knowledge to be gained by working with someone who's already been there.  Try to find someone who does (or did) the same kind of programming that you do and open a dialog with them.  Swapping war stories with someone who has 10 or 15 years more experience can help you decide what kind of things you still need to learn, and what direction you want your career to take.</htmltext>
<tokenext>Do n't overlook the knowledge to be gained by working with someone who 's already been there .
Try to find someone who does ( or did ) the same kind of programming that you do and open a dialog with them .
Swapping war stories with someone who has 10 or 15 years more experience can help you decide what kind of things you still need to learn , and what direction you want your career to take .</tokentext>
<sentencetext>Don't overlook the knowledge to be gained by working with someone who's already been there.
Try to find someone who does (or did) the same kind of programming that you do and open a dialog with them.
Swapping war stories with someone who has 10 or 15 years more experience can help you decide what kind of things you still need to learn, and what direction you want your career to take.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202176</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>Gouru</author>
	<datestamp>1266608820000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I would add to your summary:</p><p>Writing Secure Code:  Writing code that is robust and resistant to attack.  Doing this right is neither easy nor obvious.</p></htmltext>
<tokenext>I would add to your summary : Writing Secure Code : Writing code that is robust and resistant to attack .
Doing this right is neither easy nor obvious .</tokentext>
<sentencetext>I would add to your summary:Writing Secure Code:  Writing code that is robust and resistant to attack.
Doing this right is neither easy nor obvious.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199868</id>
	<title>Proper code analysis</title>
	<author>smbell</author>
	<datestamp>1266597960000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>2</modscore>
	<htmltext>I have a CS degree from a major university.  I have to disagree with most of the comments I've seen so far.  Things like design patterns, proper object modeling, even advanced data structures and algorithms can be picked up on your own with a bit of effort as you need them, and experience building real production used software is the key to hone those skills.
<br> <br>
IMHO there are two things that I got from school.  How to properly analyze code (in terms of processing time, memory usage,<nobr> <wbr></nobr>...) so that I could accurately predict how it would behave under different conditions (especially when some of those conditions can't easily be tested).  And an introduction to a large swath of computer science terms and facets, so that years later something comes up and I have a faint understanding of where to start looking.
<br> <br>
The code quality, design, and ability to apply [insert new hot term of the day] correctly all come from real world experience.  And I do think you have to get that experience in a professional setting (I would consider much of the open source world profession, just FYI), hobbyist work just won't let you grow the way you need to.</htmltext>
<tokenext>I have a CS degree from a major university .
I have to disagree with most of the comments I 've seen so far .
Things like design patterns , proper object modeling , even advanced data structures and algorithms can be picked up on your own with a bit of effort as you need them , and experience building real production used software is the key to hone those skills .
IMHO there are two things that I got from school .
How to properly analyze code ( in terms of processing time , memory usage , ... ) so that I could accurately predict how it would behave under different conditions ( especially when some of those conditions ca n't easily be tested ) .
And an introduction to a large swath of computer science terms and facets , so that years later something comes up and I have a faint understanding of where to start looking .
The code quality , design , and ability to apply [ insert new hot term of the day ] correctly all come from real world experience .
And I do think you have to get that experience in a professional setting ( I would consider much of the open source world profession , just FYI ) , hobbyist work just wo n't let you grow the way you need to .</tokentext>
<sentencetext>I have a CS degree from a major university.
I have to disagree with most of the comments I've seen so far.
Things like design patterns, proper object modeling, even advanced data structures and algorithms can be picked up on your own with a bit of effort as you need them, and experience building real production used software is the key to hone those skills.
IMHO there are two things that I got from school.
How to properly analyze code (in terms of processing time, memory usage, ...) so that I could accurately predict how it would behave under different conditions (especially when some of those conditions can't easily be tested).
And an introduction to a large swath of computer science terms and facets, so that years later something comes up and I have a faint understanding of where to start looking.
The code quality, design, and ability to apply [insert new hot term of the day] correctly all come from real world experience.
And I do think you have to get that experience in a professional setting (I would consider much of the open source world profession, just FYI), hobbyist work just won't let you grow the way you need to.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31209002</id>
	<title>If we ask a job recruiter...</title>
	<author>Anonymous</author>
	<datestamp>1266665040000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>A job recruiter would say, "You don't have at least 7 years experience in Microsoft SQL Server 2008... I'm sorry but you're not a fit at this organization.  Best of luck!"</htmltext>
<tokenext>A job recruiter would say , " You do n't have at least 7 years experience in Microsoft SQL Server 2008... I 'm sorry but you 're not a fit at this organization .
Best of luck !
"</tokentext>
<sentencetext>A job recruiter would say, "You don't have at least 7 years experience in Microsoft SQL Server 2008... I'm sorry but you're not a fit at this organization.
Best of luck!
"</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200858</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>coaxial</author>
	<datestamp>1266602220000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>No one cares about Turing machines.  They're an abstraction,<br>Prog languages and architecture also don't really matter unless you're working on something very close to the metal.</p></htmltext>
<tokenext>No one cares about Turing machines .
They 're an abstraction,Prog languages and architecture also do n't really matter unless you 're working on something very close to the metal .</tokentext>
<sentencetext>No one cares about Turing machines.
They're an abstraction,Prog languages and architecture also don't really matter unless you're working on something very close to the metal.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31207188</id>
	<title>Math</title>
	<author>konohitowa</author>
	<datestamp>1266594240000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Perhaps I missed some comments due to my filter settings, but I didn't see anyone directly recommending Discrete Math/Finite Math. That's a pretty important topic -- I did see it sort of mentioned in passing as part of other topics, but having a deep understanding of discrete would help a lot. Boolean logic topics like DeMorgan's theorem &amp; Carnot maps can help you considerably with optimization and even just reviewing the logic portions can help you avoid those "if/else/oops" scenarios wherein you forget to consider one of the cases of a logic statement.</p><p>Linear Algebra can also be extremely helpful for a fair number of problems that arise and it can also lead you into linear optimization topics.</p><p>Although more of an applied math topic rather than math itself, Digital Design can have a tremendous impact on your understanding of the system -- particularly when dealing with hardware or a compiler bug.</p><p>And to toss in some non-math, Operating Systems is another great topic -- as well as Compiler Design. You'll see lots of methods for doing things that you have to do regularly anyway while gaining a deeper understanding of the "behind the scenes" operations.</p></htmltext>
<tokenext>Perhaps I missed some comments due to my filter settings , but I did n't see anyone directly recommending Discrete Math/Finite Math .
That 's a pretty important topic -- I did see it sort of mentioned in passing as part of other topics , but having a deep understanding of discrete would help a lot .
Boolean logic topics like DeMorgan 's theorem &amp; Carnot maps can help you considerably with optimization and even just reviewing the logic portions can help you avoid those " if/else/oops " scenarios wherein you forget to consider one of the cases of a logic statement.Linear Algebra can also be extremely helpful for a fair number of problems that arise and it can also lead you into linear optimization topics.Although more of an applied math topic rather than math itself , Digital Design can have a tremendous impact on your understanding of the system -- particularly when dealing with hardware or a compiler bug.And to toss in some non-math , Operating Systems is another great topic -- as well as Compiler Design .
You 'll see lots of methods for doing things that you have to do regularly anyway while gaining a deeper understanding of the " behind the scenes " operations .</tokentext>
<sentencetext>Perhaps I missed some comments due to my filter settings, but I didn't see anyone directly recommending Discrete Math/Finite Math.
That's a pretty important topic -- I did see it sort of mentioned in passing as part of other topics, but having a deep understanding of discrete would help a lot.
Boolean logic topics like DeMorgan's theorem &amp; Carnot maps can help you considerably with optimization and even just reviewing the logic portions can help you avoid those "if/else/oops" scenarios wherein you forget to consider one of the cases of a logic statement.Linear Algebra can also be extremely helpful for a fair number of problems that arise and it can also lead you into linear optimization topics.Although more of an applied math topic rather than math itself, Digital Design can have a tremendous impact on your understanding of the system -- particularly when dealing with hardware or a compiler bug.And to toss in some non-math, Operating Systems is another great topic -- as well as Compiler Design.
You'll see lots of methods for doing things that you have to do regularly anyway while gaining a deeper understanding of the "behind the scenes" operations.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202332</id>
	<title>Keep at It</title>
	<author>Plekto</author>
	<datestamp>1266609900000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>There are two main types of computer people in this world - those who know theory and books and those who know from experience.  If I was running a company, I'd want 100\% self-taught and capable programmers and not a bunch of cookie-cutter designers.  Sure, the formally taught employees might get the job done a bit faster most of the time, but thinking laterally and outside of the box as well as cleaning up and fixing problems and emergencies, well, that's something that self-taught people have to do or have done many times in the past.  It's a different type of thinking, really.  And it's something that a lot of college educated students just don't have skills in or have to spend years learning.</p><p>Perhaps another example would be those 100-in-1 electronics kits that a lot of us had growing up.  We may replace components now instead of fixing the actual parts that broke, but there's a world of difference between an engineer or even a PC tech who understands and knows why the stuff works from using/making it themselves versus just what they were taught somewhere.  One knows why it failed and will likely fail again, and the other knows how to use a screwdriver. (and yes they still make those kits, so get your kids one!)</p><p>Plus, most college courses require you to take tons of useless classes to GET to the more advanced stuff that you could just as easily go out and buy a book on Linux and save yourself 1-2 years of classes.  Of course, your education matters, since if for no other reason than to get that interview, but programming should be something you know and learn and not necessarily what you actually got your degree in.  IMO, the smart CIS major switches to Math, Physics, or Engineering instead and does programming as a skill they happen to know.</p></htmltext>
<tokenext>There are two main types of computer people in this world - those who know theory and books and those who know from experience .
If I was running a company , I 'd want 100 \ % self-taught and capable programmers and not a bunch of cookie-cutter designers .
Sure , the formally taught employees might get the job done a bit faster most of the time , but thinking laterally and outside of the box as well as cleaning up and fixing problems and emergencies , well , that 's something that self-taught people have to do or have done many times in the past .
It 's a different type of thinking , really .
And it 's something that a lot of college educated students just do n't have skills in or have to spend years learning.Perhaps another example would be those 100-in-1 electronics kits that a lot of us had growing up .
We may replace components now instead of fixing the actual parts that broke , but there 's a world of difference between an engineer or even a PC tech who understands and knows why the stuff works from using/making it themselves versus just what they were taught somewhere .
One knows why it failed and will likely fail again , and the other knows how to use a screwdriver .
( and yes they still make those kits , so get your kids one !
) Plus , most college courses require you to take tons of useless classes to GET to the more advanced stuff that you could just as easily go out and buy a book on Linux and save yourself 1-2 years of classes .
Of course , your education matters , since if for no other reason than to get that interview , but programming should be something you know and learn and not necessarily what you actually got your degree in .
IMO , the smart CIS major switches to Math , Physics , or Engineering instead and does programming as a skill they happen to know .</tokentext>
<sentencetext>There are two main types of computer people in this world - those who know theory and books and those who know from experience.
If I was running a company, I'd want 100\% self-taught and capable programmers and not a bunch of cookie-cutter designers.
Sure, the formally taught employees might get the job done a bit faster most of the time, but thinking laterally and outside of the box as well as cleaning up and fixing problems and emergencies, well, that's something that self-taught people have to do or have done many times in the past.
It's a different type of thinking, really.
And it's something that a lot of college educated students just don't have skills in or have to spend years learning.Perhaps another example would be those 100-in-1 electronics kits that a lot of us had growing up.
We may replace components now instead of fixing the actual parts that broke, but there's a world of difference between an engineer or even a PC tech who understands and knows why the stuff works from using/making it themselves versus just what they were taught somewhere.
One knows why it failed and will likely fail again, and the other knows how to use a screwdriver.
(and yes they still make those kits, so get your kids one!
)Plus, most college courses require you to take tons of useless classes to GET to the more advanced stuff that you could just as easily go out and buy a book on Linux and save yourself 1-2 years of classes.
Of course, your education matters, since if for no other reason than to get that interview, but programming should be something you know and learn and not necessarily what you actually got your degree in.
IMO, the smart CIS major switches to Math, Physics, or Engineering instead and does programming as a skill they happen to know.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201666</id>
	<title>Take a look at Project Euler</title>
	<author>dbdweeb</author>
	<datestamp>1266605820000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><ul>
<li>If you like solving problems...</li>
<li>If you like looking at sample code...</li>
<li>If you like learning new techniques...</li>
<li>If you have a need to prove your smarts...</li>
<li>If you program in multiple languages and like to compare them...</li>
<li>If high performance gets you all sweaty...</li>
<li>If functional programming doesn't turn you on...</li>
</ul><p>
<a href="http://projecteuler.net/" title="projecteuler.net" rel="nofollow">Take a look at Project Euler</a> [projecteuler.net]</p></htmltext>
<tokenext>If you like solving problems.. . If you like looking at sample code.. . If you like learning new techniques.. . If you have a need to prove your smarts.. . If you program in multiple languages and like to compare them.. . If high performance gets you all sweaty.. . If functional programming does n't turn you on.. . Take a look at Project Euler [ projecteuler.net ]</tokentext>
<sentencetext>
If you like solving problems...
If you like looking at sample code...
If you like learning new techniques...
If you have a need to prove your smarts...
If you program in multiple languages and like to compare them...
If high performance gets you all sweaty...
If functional programming doesn't turn you on...

Take a look at Project Euler [projecteuler.net]</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203734</id>
	<title>All the little details...</title>
	<author>Dilligent</author>
	<datestamp>1266572400000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>...you ignore when learning things on your own. Seriously, if you teach yourself a language it's usually by developing a project of your choice (mostly for the fun of it, as it has been for me). What people do is, they go for the fun bit of hacking things together to get a working piece and pick one of two choice:
* Try to use all the language features even if this means overkill for simple situations.
* Go on to piece it together and leave a horrible mess.


I used to do the latter &gt;10 years ago in that situation, starting out in the mess that Visual Basic itself is, never really realising just how bad it was. I was proud of what I'd achieved! Looking back, I can't believe I published any of that. It's when people go for the first choice and start realising how software is meant to look like from the source that they learn to be a competent programmer. There's all these intricate details like Garbage-Collection, String-Manipulation, Floating-Point Math (the point being that it is unlike mat taught at school !) and many more things like Memory-Management and some such that one *can* get to work sloppily, but it's only when one realises how to utilise these things in the correct way that i would agree self-teaching is the way to go.


I'm a self taught programmer, still in university (3rd year with an average mark of 1.8), employed as a software engineer and I'm 100\% certain I wouldn't have been able to achieve 1 quarter of these things without teaching myself how to program.<nobr> <wbr></nobr>....Yeah... it is at this point that people can rightfully say they *do* waste quite some time in university.</htmltext>
<tokenext>...you ignore when learning things on your own .
Seriously , if you teach yourself a language it 's usually by developing a project of your choice ( mostly for the fun of it , as it has been for me ) .
What people do is , they go for the fun bit of hacking things together to get a working piece and pick one of two choice : * Try to use all the language features even if this means overkill for simple situations .
* Go on to piece it together and leave a horrible mess .
I used to do the latter &gt; 10 years ago in that situation , starting out in the mess that Visual Basic itself is , never really realising just how bad it was .
I was proud of what I 'd achieved !
Looking back , I ca n't believe I published any of that .
It 's when people go for the first choice and start realising how software is meant to look like from the source that they learn to be a competent programmer .
There 's all these intricate details like Garbage-Collection , String-Manipulation , Floating-Point Math ( the point being that it is unlike mat taught at school !
) and many more things like Memory-Management and some such that one * can * get to work sloppily , but it 's only when one realises how to utilise these things in the correct way that i would agree self-teaching is the way to go .
I 'm a self taught programmer , still in university ( 3rd year with an average mark of 1.8 ) , employed as a software engineer and I 'm 100 \ % certain I would n't have been able to achieve 1 quarter of these things without teaching myself how to program .
....Yeah... it is at this point that people can rightfully say they * do * waste quite some time in university .</tokentext>
<sentencetext>...you ignore when learning things on your own.
Seriously, if you teach yourself a language it's usually by developing a project of your choice (mostly for the fun of it, as it has been for me).
What people do is, they go for the fun bit of hacking things together to get a working piece and pick one of two choice:
* Try to use all the language features even if this means overkill for simple situations.
* Go on to piece it together and leave a horrible mess.
I used to do the latter &gt;10 years ago in that situation, starting out in the mess that Visual Basic itself is, never really realising just how bad it was.
I was proud of what I'd achieved!
Looking back, I can't believe I published any of that.
It's when people go for the first choice and start realising how software is meant to look like from the source that they learn to be a competent programmer.
There's all these intricate details like Garbage-Collection, String-Manipulation, Floating-Point Math (the point being that it is unlike mat taught at school !
) and many more things like Memory-Management and some such that one *can* get to work sloppily, but it's only when one realises how to utilise these things in the correct way that i would agree self-teaching is the way to go.
I'm a self taught programmer, still in university (3rd year with an average mark of 1.8), employed as a software engineer and I'm 100\% certain I wouldn't have been able to achieve 1 quarter of these things without teaching myself how to program.
....Yeah... it is at this point that people can rightfully say they *do* waste quite some time in university.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200102</id>
	<title>Goto</title>
	<author>Anonymous</author>
	<datestamp>1266599040000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Was fun even 15 years ago to see Pascal programs full of goto loops, from people that learnt plain basic by themselves and then "upgraded" to a more serious language. The very thinking of how is the flow of a program, independant from the language used, was wrong because that "programmer" never understood some basic programming concepts. Programming has evolved with time, and chances for doing it all wrong because missing or not fully understood key concepts are bigger now.</htmltext>
<tokenext>Was fun even 15 years ago to see Pascal programs full of goto loops , from people that learnt plain basic by themselves and then " upgraded " to a more serious language .
The very thinking of how is the flow of a program , independant from the language used , was wrong because that " programmer " never understood some basic programming concepts .
Programming has evolved with time , and chances for doing it all wrong because missing or not fully understood key concepts are bigger now .</tokentext>
<sentencetext>Was fun even 15 years ago to see Pascal programs full of goto loops, from people that learnt plain basic by themselves and then "upgraded" to a more serious language.
The very thinking of how is the flow of a program, independant from the language used, was wrong because that "programmer" never understood some basic programming concepts.
Programming has evolved with time, and chances for doing it all wrong because missing or not fully understood key concepts are bigger now.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31210490</id>
	<title>Actual engineering.</title>
	<author>Cerebus</author>
	<datestamp>1266686520000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>'Nuff said.</p></htmltext>
<tokenext>'Nuff said .</tokentext>
<sentencetext>'Nuff said.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199956</id>
	<title>Self-Taught</title>
	<author>LCValentine</author>
	<datestamp>1266598320000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext><p>As a self-taught PHP and C# Developer, the biggest trouble has already been outlined as limited exposure to new concepts.  The bigger question, however, is how to gain exposure.

</p><p>#1 - User Groups
I personally don't attend user groups because I have 2 jobs, and 2 kids, however, the Ruby community has shown again and again that it works, not just for the new stuff, but for the old stuff.  They just overhauled Rails and as long as the community keeps talking, they'll do it again and again to perfection.

</p><p>#2 - Contracting
It's a large assumption, but if you have the time to learn a language, you've got time to find small contracts, and hopefully ones that will introduce you to knew people with difference foci (focuses?).  Also, digging unto other people's code helps you think outside of the structures that you taught yourself - you might even get some extra cash.  Check out craigs list, elance, etc

</p><p>#3 - Open Source
Not as good for your wallet up front, but if you think you have a unique perspective that is applicable to an existing project, donate some code.  Bug fixes are just as valuable as new features.

</p><p>#4 - Publications
I use this in the loosest sense of the word possible.  I "camp" PHP.net because there are new functions popping up all the time.  Their search database is fairly decent, so when you're thinking like a PHP dev, put a word or two in and see what pops up.  MSDN isn't too bad either, but the naming conventions vary, and it's so large that simply search for keywords is a challenge  (They have an "OrderedDictionary, but not a UniqueList...?)

</p><p>#5 - Inspiration (&amp; Perspiration)
Nothing develops with out the the will power and simply getting things done.  Going back to #3, you can simply start your own project or feature.  Lots of things are pluggable these days, and if your desired functionality doesn't exist, don't cry about it - build it!   PHP doesn't have events, because events don't make a lot of sense on the Web....   HOWEVER, if you're writing a PHP-JS-AJAX framework, then they make a LOT of sense.  Noone says you HAVE to release your code either... managing a repo is a lot of work.  The point is to build something, find the pain points, then ask yourself "Is there a better way to do this?"   Find the better way, build it, and make your life easier... then share it if you can.</p></htmltext>
<tokenext>As a self-taught PHP and C # Developer , the biggest trouble has already been outlined as limited exposure to new concepts .
The bigger question , however , is how to gain exposure .
# 1 - User Groups I personally do n't attend user groups because I have 2 jobs , and 2 kids , however , the Ruby community has shown again and again that it works , not just for the new stuff , but for the old stuff .
They just overhauled Rails and as long as the community keeps talking , they 'll do it again and again to perfection .
# 2 - Contracting It 's a large assumption , but if you have the time to learn a language , you 've got time to find small contracts , and hopefully ones that will introduce you to knew people with difference foci ( focuses ? ) .
Also , digging unto other people 's code helps you think outside of the structures that you taught yourself - you might even get some extra cash .
Check out craigs list , elance , etc # 3 - Open Source Not as good for your wallet up front , but if you think you have a unique perspective that is applicable to an existing project , donate some code .
Bug fixes are just as valuable as new features .
# 4 - Publications I use this in the loosest sense of the word possible .
I " camp " PHP.net because there are new functions popping up all the time .
Their search database is fairly decent , so when you 're thinking like a PHP dev , put a word or two in and see what pops up .
MSDN is n't too bad either , but the naming conventions vary , and it 's so large that simply search for keywords is a challenge ( They have an " OrderedDictionary , but not a UniqueList... ?
) # 5 - Inspiration ( &amp; Perspiration ) Nothing develops with out the the will power and simply getting things done .
Going back to # 3 , you can simply start your own project or feature .
Lots of things are pluggable these days , and if your desired functionality does n't exist , do n't cry about it - build it !
PHP does n't have events , because events do n't make a lot of sense on the Web.... HOWEVER , if you 're writing a PHP-JS-AJAX framework , then they make a LOT of sense .
Noone says you HAVE to release your code either... managing a repo is a lot of work .
The point is to build something , find the pain points , then ask yourself " Is there a better way to do this ?
" Find the better way , build it , and make your life easier... then share it if you can .</tokentext>
<sentencetext>As a self-taught PHP and C# Developer, the biggest trouble has already been outlined as limited exposure to new concepts.
The bigger question, however, is how to gain exposure.
#1 - User Groups
I personally don't attend user groups because I have 2 jobs, and 2 kids, however, the Ruby community has shown again and again that it works, not just for the new stuff, but for the old stuff.
They just overhauled Rails and as long as the community keeps talking, they'll do it again and again to perfection.
#2 - Contracting
It's a large assumption, but if you have the time to learn a language, you've got time to find small contracts, and hopefully ones that will introduce you to knew people with difference foci (focuses?).
Also, digging unto other people's code helps you think outside of the structures that you taught yourself - you might even get some extra cash.
Check out craigs list, elance, etc

#3 - Open Source
Not as good for your wallet up front, but if you think you have a unique perspective that is applicable to an existing project, donate some code.
Bug fixes are just as valuable as new features.
#4 - Publications
I use this in the loosest sense of the word possible.
I "camp" PHP.net because there are new functions popping up all the time.
Their search database is fairly decent, so when you're thinking like a PHP dev, put a word or two in and see what pops up.
MSDN isn't too bad either, but the naming conventions vary, and it's so large that simply search for keywords is a challenge  (They have an "OrderedDictionary, but not a UniqueList...?
)

#5 - Inspiration (&amp; Perspiration)
Nothing develops with out the the will power and simply getting things done.
Going back to #3, you can simply start your own project or feature.
Lots of things are pluggable these days, and if your desired functionality doesn't exist, don't cry about it - build it!
PHP doesn't have events, because events don't make a lot of sense on the Web....   HOWEVER, if you're writing a PHP-JS-AJAX framework, then they make a LOT of sense.
Noone says you HAVE to release your code either... managing a repo is a lot of work.
The point is to build something, find the pain points, then ask yourself "Is there a better way to do this?
"   Find the better way, build it, and make your life easier... then share it if you can.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200582</id>
	<title>Database design; low-level system architecture</title>
	<author>cduffy</author>
	<datestamp>1266601020000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Of my four years of formal education, two classes stand out:</p><p>Database design - If you don't know the formal procedure for database normalization, you shouldn't be designing a schema -- not because you'll necessarily use that procedure, but because you know the factors to take into consideration.</p><p>System architecture - I think the one most useful class I ever took was the one that stopped the CPU from being a black box. I had an old-school professor, and he went deep -- we started off with digital logic, Karnaugh maps and the like, and by our final could draw the extra data paths needed to be able to implement a new instruction on a MIPS chip.</p><p>...and then there are the opportunities one gets access to as a result of having been at school; much of what I know I learned at my internship (being one of the few userspace developers in MontaVista Software's sea of Linux kernel programmers around the tail end of the boom), not an opportunity I'd have acquired on my own.</p></htmltext>
<tokenext>Of my four years of formal education , two classes stand out : Database design - If you do n't know the formal procedure for database normalization , you should n't be designing a schema -- not because you 'll necessarily use that procedure , but because you know the factors to take into consideration.System architecture - I think the one most useful class I ever took was the one that stopped the CPU from being a black box .
I had an old-school professor , and he went deep -- we started off with digital logic , Karnaugh maps and the like , and by our final could draw the extra data paths needed to be able to implement a new instruction on a MIPS chip....and then there are the opportunities one gets access to as a result of having been at school ; much of what I know I learned at my internship ( being one of the few userspace developers in MontaVista Software 's sea of Linux kernel programmers around the tail end of the boom ) , not an opportunity I 'd have acquired on my own .</tokentext>
<sentencetext>Of my four years of formal education, two classes stand out:Database design - If you don't know the formal procedure for database normalization, you shouldn't be designing a schema -- not because you'll necessarily use that procedure, but because you know the factors to take into consideration.System architecture - I think the one most useful class I ever took was the one that stopped the CPU from being a black box.
I had an old-school professor, and he went deep -- we started off with digital logic, Karnaugh maps and the like, and by our final could draw the extra data paths needed to be able to implement a new instruction on a MIPS chip....and then there are the opportunities one gets access to as a result of having been at school; much of what I know I learned at my internship (being one of the few userspace developers in MontaVista Software's sea of Linux kernel programmers around the tail end of the boom), not an opportunity I'd have acquired on my own.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31212360</id>
	<title>Self-taught is good. Self-important is not.</title>
	<author>Anonymous</author>
	<datestamp>1266699180000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>In my experience, self-taught programmers lack humility, in that they tend to think they know more than they do, and generally assume that they are not missing out on anything that a formal education in computer science / electrical engineering could have taught them. They also tend to perform poorly in a team environment. This second observation is most troublesome, as there is not a complex software project that can be successful without a strong team. Some of these problems may be more of a reflection on the chip they carry around on their shoulders if they have to work with people with more credentials on their resume. Or they may really be as neurotic as you perceive them to be. If they perceive they might be shown up they become overly defensive of their ideas, even though all good engineers know there is usually more than one way to solve any given problem. They also tend to seek out positions of authority, even though they usually have no business managing people. In short, good luck working for them. They tend to be everywhere.</p><p>Oh, and the algorithm crap is a complete waste of time. Most software projects have so many more important problems to deal with every day than saving a few clock cycles on a modern 4 GHz quad core. I'm not saying go ahead and write 'tard code and make stuff that is slow just because you're lazy. It's just not as important as making sure you allocated enough buffer space and actually validated that user input stream. And what's the point of saving those extra clock cycles if you continuously have to fix buggy code that was rushed out the door and that wasn't needed in the first place because some poor excuse for a product manager keeps asking for the wrong features from the engineers? Software sucks. If you are motivated enough to self-teach, get out your math texts and get a real job doing anything other than software.</p></htmltext>
<tokenext>In my experience , self-taught programmers lack humility , in that they tend to think they know more than they do , and generally assume that they are not missing out on anything that a formal education in computer science / electrical engineering could have taught them .
They also tend to perform poorly in a team environment .
This second observation is most troublesome , as there is not a complex software project that can be successful without a strong team .
Some of these problems may be more of a reflection on the chip they carry around on their shoulders if they have to work with people with more credentials on their resume .
Or they may really be as neurotic as you perceive them to be .
If they perceive they might be shown up they become overly defensive of their ideas , even though all good engineers know there is usually more than one way to solve any given problem .
They also tend to seek out positions of authority , even though they usually have no business managing people .
In short , good luck working for them .
They tend to be everywhere.Oh , and the algorithm crap is a complete waste of time .
Most software projects have so many more important problems to deal with every day than saving a few clock cycles on a modern 4 GHz quad core .
I 'm not saying go ahead and write 'tard code and make stuff that is slow just because you 're lazy .
It 's just not as important as making sure you allocated enough buffer space and actually validated that user input stream .
And what 's the point of saving those extra clock cycles if you continuously have to fix buggy code that was rushed out the door and that was n't needed in the first place because some poor excuse for a product manager keeps asking for the wrong features from the engineers ?
Software sucks .
If you are motivated enough to self-teach , get out your math texts and get a real job doing anything other than software .</tokentext>
<sentencetext>In my experience, self-taught programmers lack humility, in that they tend to think they know more than they do, and generally assume that they are not missing out on anything that a formal education in computer science / electrical engineering could have taught them.
They also tend to perform poorly in a team environment.
This second observation is most troublesome, as there is not a complex software project that can be successful without a strong team.
Some of these problems may be more of a reflection on the chip they carry around on their shoulders if they have to work with people with more credentials on their resume.
Or they may really be as neurotic as you perceive them to be.
If they perceive they might be shown up they become overly defensive of their ideas, even though all good engineers know there is usually more than one way to solve any given problem.
They also tend to seek out positions of authority, even though they usually have no business managing people.
In short, good luck working for them.
They tend to be everywhere.Oh, and the algorithm crap is a complete waste of time.
Most software projects have so many more important problems to deal with every day than saving a few clock cycles on a modern 4 GHz quad core.
I'm not saying go ahead and write 'tard code and make stuff that is slow just because you're lazy.
It's just not as important as making sure you allocated enough buffer space and actually validated that user input stream.
And what's the point of saving those extra clock cycles if you continuously have to fix buggy code that was rushed out the door and that wasn't needed in the first place because some poor excuse for a product manager keeps asking for the wrong features from the engineers?
Software sucks.
If you are motivated enough to self-teach, get out your math texts and get a real job doing anything other than software.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31205762</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>jeff4747</author>
	<datestamp>1266581760000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I'm mostly self-taught with a couple CS classes.</p><p>IMO the big thing the new CS grad is missing "Engineering".</p><p>The problem with CS is that it's science.  It really needs to be broken up into "the researchers" and "those that apply the research".  A little like the difference between Materials Science and Civil Engineering.</p><p>The vast majority of people who get CS degrees would be better served by some sort of "Software Engineering" degree.  They need to know how to put the Legos together well, they won't be creating new Legos.</p><p>In a similar vein, new CS grads seem to lack the training on how to work on projects of significant size with a several people (why have source code control, what the 'test' department really does, and so on).  This isn't surprising since the vast majority of CS courses consist of making a bunch of small programs to illustrate a particular technique and then immediately abandoning them once it's time for the next lesson/course.  At best you have a "Final Project" with 4 people in it working on a relatively contrived problem.  I can't really blame the schools on this one though.  There really isn't time to build a large and complex system within a normal college curriculum.</p><p>Which leads to maintainability.  If you're just doing little programs for a single course, you don't have to worry about maintenance of the code.  Then they get their first 'real job'.  Then they're desperately trying to remember the details of some clever trick they put in a year ago that is now causing a defect.  The complex implementation looked really nice when they wrote it, and it saved 250ms so it's a huge optimization....problem is it's saving 250ms per hour and a bug somewhere in it is corrupting customer data.</p><p>You won't remember why your optimizations were optimizations, and you won't remember what the tricks were.  Comment liberally and don't over-optimize - be 'tricky' only when it counts, and brute force it the other 95\% of the time.</p><p>Lastly, not understanding scheduling.  When your boss tells you to do something impossible, the best response is "That's impossible in the remaining schedule", not frantically working 18 hour days for 2 weeks until you produce something that still blows up 30\% of the time because you were so exhausted by the end.</p><p>Pulling all-nighters makes you appear heroic in College.  Your boss thinks it looks like you don't know how to schedule.  There will \_ALWAYS\_ be "crap that appears out of nowhere".  Put some slack in your estimates.</p></htmltext>
<tokenext>I 'm mostly self-taught with a couple CS classes.IMO the big thing the new CS grad is missing " Engineering " .The problem with CS is that it 's science .
It really needs to be broken up into " the researchers " and " those that apply the research " .
A little like the difference between Materials Science and Civil Engineering.The vast majority of people who get CS degrees would be better served by some sort of " Software Engineering " degree .
They need to know how to put the Legos together well , they wo n't be creating new Legos.In a similar vein , new CS grads seem to lack the training on how to work on projects of significant size with a several people ( why have source code control , what the 'test ' department really does , and so on ) .
This is n't surprising since the vast majority of CS courses consist of making a bunch of small programs to illustrate a particular technique and then immediately abandoning them once it 's time for the next lesson/course .
At best you have a " Final Project " with 4 people in it working on a relatively contrived problem .
I ca n't really blame the schools on this one though .
There really is n't time to build a large and complex system within a normal college curriculum.Which leads to maintainability .
If you 're just doing little programs for a single course , you do n't have to worry about maintenance of the code .
Then they get their first 'real job' .
Then they 're desperately trying to remember the details of some clever trick they put in a year ago that is now causing a defect .
The complex implementation looked really nice when they wrote it , and it saved 250ms so it 's a huge optimization....problem is it 's saving 250ms per hour and a bug somewhere in it is corrupting customer data.You wo n't remember why your optimizations were optimizations , and you wo n't remember what the tricks were .
Comment liberally and do n't over-optimize - be 'tricky ' only when it counts , and brute force it the other 95 \ % of the time.Lastly , not understanding scheduling .
When your boss tells you to do something impossible , the best response is " That 's impossible in the remaining schedule " , not frantically working 18 hour days for 2 weeks until you produce something that still blows up 30 \ % of the time because you were so exhausted by the end.Pulling all-nighters makes you appear heroic in College .
Your boss thinks it looks like you do n't know how to schedule .
There will \ _ALWAYS \ _ be " crap that appears out of nowhere " .
Put some slack in your estimates .</tokentext>
<sentencetext>I'm mostly self-taught with a couple CS classes.IMO the big thing the new CS grad is missing "Engineering".The problem with CS is that it's science.
It really needs to be broken up into "the researchers" and "those that apply the research".
A little like the difference between Materials Science and Civil Engineering.The vast majority of people who get CS degrees would be better served by some sort of "Software Engineering" degree.
They need to know how to put the Legos together well, they won't be creating new Legos.In a similar vein, new CS grads seem to lack the training on how to work on projects of significant size with a several people (why have source code control, what the 'test' department really does, and so on).
This isn't surprising since the vast majority of CS courses consist of making a bunch of small programs to illustrate a particular technique and then immediately abandoning them once it's time for the next lesson/course.
At best you have a "Final Project" with 4 people in it working on a relatively contrived problem.
I can't really blame the schools on this one though.
There really isn't time to build a large and complex system within a normal college curriculum.Which leads to maintainability.
If you're just doing little programs for a single course, you don't have to worry about maintenance of the code.
Then they get their first 'real job'.
Then they're desperately trying to remember the details of some clever trick they put in a year ago that is now causing a defect.
The complex implementation looked really nice when they wrote it, and it saved 250ms so it's a huge optimization....problem is it's saving 250ms per hour and a bug somewhere in it is corrupting customer data.You won't remember why your optimizations were optimizations, and you won't remember what the tricks were.
Comment liberally and don't over-optimize - be 'tricky' only when it counts, and brute force it the other 95\% of the time.Lastly, not understanding scheduling.
When your boss tells you to do something impossible, the best response is "That's impossible in the remaining schedule", not frantically working 18 hour days for 2 weeks until you produce something that still blows up 30\% of the time because you were so exhausted by the end.Pulling all-nighters makes you appear heroic in College.
Your boss thinks it looks like you don't know how to schedule.
There will \_ALWAYS\_ be "crap that appears out of nowhere".
Put some slack in your estimates.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201584</id>
	<title>Even "Experts" Struggle with OOP</title>
	<author>Tablizer</author>
	<datestamp>1266605460000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><blockquote><div><p>Knowing when to make something an object... when to not make something an object.</p></div></blockquote><p>This is something even experts struggle with. As a long-time skeptic of OOP[1], I've tried to find a consensus about the "proper" way to architect an app using OOP so that I have something consistent to dissect and publicly analyze besides "toy" examples, but found the OOP author/proponents' answers either vary widely per practitioner or are too open-ended.</p><p>They pretty much say, "I know good OO when I see it, but I cannot write down solid rules for recognizing and/or creating it". It's <b>difficult to dissect and analyze the benefits of techniques if they are a moving target or non-describable</b>.</p><p>[1] It has its place, but for the most part is over-hyped. It's one of many tools<br>
&nbsp; &nbsp;</p></div>
	</htmltext>
<tokenext>Knowing when to make something an object... when to not make something an object.This is something even experts struggle with .
As a long-time skeptic of OOP [ 1 ] , I 've tried to find a consensus about the " proper " way to architect an app using OOP so that I have something consistent to dissect and publicly analyze besides " toy " examples , but found the OOP author/proponents ' answers either vary widely per practitioner or are too open-ended.They pretty much say , " I know good OO when I see it , but I can not write down solid rules for recognizing and/or creating it " .
It 's difficult to dissect and analyze the benefits of techniques if they are a moving target or non-describable .
[ 1 ] It has its place , but for the most part is over-hyped .
It 's one of many tools    </tokentext>
<sentencetext>Knowing when to make something an object... when to not make something an object.This is something even experts struggle with.
As a long-time skeptic of OOP[1], I've tried to find a consensus about the "proper" way to architect an app using OOP so that I have something consistent to dissect and publicly analyze besides "toy" examples, but found the OOP author/proponents' answers either vary widely per practitioner or are too open-ended.They pretty much say, "I know good OO when I see it, but I cannot write down solid rules for recognizing and/or creating it".
It's difficult to dissect and analyze the benefits of techniques if they are a moving target or non-describable.
[1] It has its place, but for the most part is over-hyped.
It's one of many tools
   
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31211074</id>
	<title>By far the biggest issue I see is ...</title>
	<author>Robb</author>
	<datestamp>1266691380000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Many self-taught programmers lack even a basic understanding of algorithmic complexity. This is the single biggest issue I run into in industry and should be one that isn't too hard to fix. Again and again I find people have written some algorithm that just doesn't scale to larger amounts of data because it is n^3 or n^4 instead of linear.

After that I would say it is a good grasp of some of the ideas in functional programming particularly recursion.

There are a lot of other things I run into but I never noticed that self-taught programmers were more prone to them than others.</htmltext>
<tokenext>Many self-taught programmers lack even a basic understanding of algorithmic complexity .
This is the single biggest issue I run into in industry and should be one that is n't too hard to fix .
Again and again I find people have written some algorithm that just does n't scale to larger amounts of data because it is n ^ 3 or n ^ 4 instead of linear .
After that I would say it is a good grasp of some of the ideas in functional programming particularly recursion .
There are a lot of other things I run into but I never noticed that self-taught programmers were more prone to them than others .</tokentext>
<sentencetext>Many self-taught programmers lack even a basic understanding of algorithmic complexity.
This is the single biggest issue I run into in industry and should be one that isn't too hard to fix.
Again and again I find people have written some algorithm that just doesn't scale to larger amounts of data because it is n^3 or n^4 instead of linear.
After that I would say it is a good grasp of some of the ideas in functional programming particularly recursion.
There are a lot of other things I run into but I never noticed that self-taught programmers were more prone to them than others.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203584</id>
	<title>Freethinking...</title>
	<author>Anonymous</author>
	<datestamp>1266571920000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Freethinking is the most important thing to teach yourself: see all the "design patterns" hints here and people modding them +5. That's terrible "groupthink". Design patterns are mostly workaround 3GL defects, probably 75\% of them yet who understands that? Who knows what a 3GL is? I'm self-taught and started with 2GL, eat that youngster<nobr> <wbr></nobr>;)</p><p>When you read things like "Java doesn't support multiple inheritance", take it with a grain salt. Exercise freethinking. Is inheritance only "subclassing+subtyping inheritance"? Of course not. So maybe that multiple interface inheritance is inheritance after all: multiple subtyping inheritance + delegation is all that is needed to translate *any* OOA/D to OOP. etc.</p><p>Most books s*cks big fat azurean mega donk*y dick.</p><p>A book on design patterns that doesn't start by acknowledging that most design patterns are workarounds specific 3GL defects isn't worth your time.</p><p>When you read something "accepted" then think "oh, that's what they *think*, why do they think that?". Don't take what you read for granted.</p><p>Read Knuth if your math oriented. That's "all" you need to know. All the rest is just the latest fluff du jour and as long as you have sound basis there's not a single buzzword technology that cannot be easily mastered.</p></htmltext>
<tokenext>Freethinking is the most important thing to teach yourself : see all the " design patterns " hints here and people modding them + 5 .
That 's terrible " groupthink " .
Design patterns are mostly workaround 3GL defects , probably 75 \ % of them yet who understands that ?
Who knows what a 3GL is ?
I 'm self-taught and started with 2GL , eat that youngster ; ) When you read things like " Java does n't support multiple inheritance " , take it with a grain salt .
Exercise freethinking .
Is inheritance only " subclassing + subtyping inheritance " ?
Of course not .
So maybe that multiple interface inheritance is inheritance after all : multiple subtyping inheritance + delegation is all that is needed to translate * any * OOA/D to OOP .
etc.Most books s * cks big fat azurean mega donk * y dick.A book on design patterns that does n't start by acknowledging that most design patterns are workarounds specific 3GL defects is n't worth your time.When you read something " accepted " then think " oh , that 's what they * think * , why do they think that ? " .
Do n't take what you read for granted.Read Knuth if your math oriented .
That 's " all " you need to know .
All the rest is just the latest fluff du jour and as long as you have sound basis there 's not a single buzzword technology that can not be easily mastered .</tokentext>
<sentencetext>Freethinking is the most important thing to teach yourself: see all the "design patterns" hints here and people modding them +5.
That's terrible "groupthink".
Design patterns are mostly workaround 3GL defects, probably 75\% of them yet who understands that?
Who knows what a 3GL is?
I'm self-taught and started with 2GL, eat that youngster ;)When you read things like "Java doesn't support multiple inheritance", take it with a grain salt.
Exercise freethinking.
Is inheritance only "subclassing+subtyping inheritance"?
Of course not.
So maybe that multiple interface inheritance is inheritance after all: multiple subtyping inheritance + delegation is all that is needed to translate *any* OOA/D to OOP.
etc.Most books s*cks big fat azurean mega donk*y dick.A book on design patterns that doesn't start by acknowledging that most design patterns are workarounds specific 3GL defects isn't worth your time.When you read something "accepted" then think "oh, that's what they *think*, why do they think that?".
Don't take what you read for granted.Read Knuth if your math oriented.
That's "all" you need to know.
All the rest is just the latest fluff du jour and as long as you have sound basis there's not a single buzzword technology that cannot be easily mastered.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203008</id>
	<title>I would REALLY recommend watching these</title>
	<author>themoneyish</author>
	<datestamp>1266613080000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>This U.C. Berkeley Data Structures class would help a lot:
<br> <br>
<a href="http://www.youtube.com/view\_play\_list?p=4BBB74C7D2A1049C&amp;search\_query=berkeley+cs+61b&amp;rclk=pti" title="youtube.com" rel="nofollow">http://www.youtube.com/view\_play\_list?p=4BBB74C7D2A1049C&amp;search\_query=berkeley+cs+61b&amp;rclk=pti</a> [youtube.com]
<br> <br>
You could probably go through all the lectures in a month and you would know a lot more than most programmers in the industry!</htmltext>
<tokenext>This U.C .
Berkeley Data Structures class would help a lot : http : //www.youtube.com/view \ _play \ _list ? p = 4BBB74C7D2A1049C&amp;search \ _query = berkeley + cs + 61b&amp;rclk = pti [ youtube.com ] You could probably go through all the lectures in a month and you would know a lot more than most programmers in the industry !</tokentext>
<sentencetext>This U.C.
Berkeley Data Structures class would help a lot:
 
http://www.youtube.com/view\_play\_list?p=4BBB74C7D2A1049C&amp;search\_query=berkeley+cs+61b&amp;rclk=pti [youtube.com]
 
You could probably go through all the lectures in a month and you would know a lot more than most programmers in the industry!</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202110</id>
	<title>Code Management</title>
	<author>Beardo the Bearded</author>
	<datestamp>1266608400000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>One thing that you're going to be seriously lacking in knowledge is code management.</p><p>You've got to use something like CVS or Subversion to keep track of your code. (Both tools are free) If you aren't using a CMS, then you don't have code, you have a bunch of text files that happen to compile. You can check differences, make rollbacks, and use a lot of great tools to track what's been going on in your codebase. You can try something new and then either integrate it or dump it. I used TortoiseCVS as the front-end client for CVS for years. (When I moved into PLCs, I couldn't find a tool that would work, which was quite terrible.)</p><p>Nobody teaches you that, even if you go to school.</p><p>You'll also want to learn some scripting, like Tcl / Tk, so you can run automatic tests. Nothing shows your edge conditions like a mindless script.</p><p>Learn how to comment and be consistent in your code. Use good and obvious variable names with consistent syntax. If you want to use CamelCasing, that's fine. If you want to use ALL\_CAPS\_WITH\_UNDERLINES, that's weird but okay. Here's the stumbling block: The code should obviously tell you WHAT it is doing. The comments should tell you <i>why</i> it's doing that. I wrote a Viterbi decoder that was about 30 lines of code. With the comments, it was closer to 130 because it was a weird and intricate system that required a lot of explaining. Trust me, when you go back in five years and wonder what in the hell you were thinking five years ago, those comments will save you a lot of grief. People who say they don't have to comment are either terrible programmers or terribly inexperienced, NO EXCEPTIONS.</p></htmltext>
<tokenext>One thing that you 're going to be seriously lacking in knowledge is code management.You 've got to use something like CVS or Subversion to keep track of your code .
( Both tools are free ) If you are n't using a CMS , then you do n't have code , you have a bunch of text files that happen to compile .
You can check differences , make rollbacks , and use a lot of great tools to track what 's been going on in your codebase .
You can try something new and then either integrate it or dump it .
I used TortoiseCVS as the front-end client for CVS for years .
( When I moved into PLCs , I could n't find a tool that would work , which was quite terrible .
) Nobody teaches you that , even if you go to school.You 'll also want to learn some scripting , like Tcl / Tk , so you can run automatic tests .
Nothing shows your edge conditions like a mindless script.Learn how to comment and be consistent in your code .
Use good and obvious variable names with consistent syntax .
If you want to use CamelCasing , that 's fine .
If you want to use ALL \ _CAPS \ _WITH \ _UNDERLINES , that 's weird but okay .
Here 's the stumbling block : The code should obviously tell you WHAT it is doing .
The comments should tell you why it 's doing that .
I wrote a Viterbi decoder that was about 30 lines of code .
With the comments , it was closer to 130 because it was a weird and intricate system that required a lot of explaining .
Trust me , when you go back in five years and wonder what in the hell you were thinking five years ago , those comments will save you a lot of grief .
People who say they do n't have to comment are either terrible programmers or terribly inexperienced , NO EXCEPTIONS .</tokentext>
<sentencetext>One thing that you're going to be seriously lacking in knowledge is code management.You've got to use something like CVS or Subversion to keep track of your code.
(Both tools are free) If you aren't using a CMS, then you don't have code, you have a bunch of text files that happen to compile.
You can check differences, make rollbacks, and use a lot of great tools to track what's been going on in your codebase.
You can try something new and then either integrate it or dump it.
I used TortoiseCVS as the front-end client for CVS for years.
(When I moved into PLCs, I couldn't find a tool that would work, which was quite terrible.
)Nobody teaches you that, even if you go to school.You'll also want to learn some scripting, like Tcl / Tk, so you can run automatic tests.
Nothing shows your edge conditions like a mindless script.Learn how to comment and be consistent in your code.
Use good and obvious variable names with consistent syntax.
If you want to use CamelCasing, that's fine.
If you want to use ALL\_CAPS\_WITH\_UNDERLINES, that's weird but okay.
Here's the stumbling block: The code should obviously tell you WHAT it is doing.
The comments should tell you why it's doing that.
I wrote a Viterbi decoder that was about 30 lines of code.
With the comments, it was closer to 130 because it was a weird and intricate system that required a lot of explaining.
Trust me, when you go back in five years and wonder what in the hell you were thinking five years ago, those comments will save you a lot of grief.
People who say they don't have to comment are either terrible programmers or terribly inexperienced, NO EXCEPTIONS.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31222546</id>
	<title>Two words:</title>
	<author>Anonymous</author>
	<datestamp>1266750720000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Normalization Theory.</p><p>Seriously, the percentage self-taught programmers who slap together databases without the faintest clue is very close to 99.99999\% I have seen far too many databases "designed" by these folk with data being duplicated, triplicated, split into 2, 3 or 5 tables (I kid you not!) - collecting their money and walking away. Then some poor slob (like me) has to go in and try to untangle the mess and rescue the data.</p><p>Sigh.</p></htmltext>
<tokenext>Normalization Theory.Seriously , the percentage self-taught programmers who slap together databases without the faintest clue is very close to 99.99999 \ % I have seen far too many databases " designed " by these folk with data being duplicated , triplicated , split into 2 , 3 or 5 tables ( I kid you not !
) - collecting their money and walking away .
Then some poor slob ( like me ) has to go in and try to untangle the mess and rescue the data.Sigh .</tokentext>
<sentencetext>Normalization Theory.Seriously, the percentage self-taught programmers who slap together databases without the faintest clue is very close to 99.99999\% I have seen far too many databases "designed" by these folk with data being duplicated, triplicated, split into 2, 3 or 5 tables (I kid you not!
) - collecting their money and walking away.
Then some poor slob (like me) has to go in and try to untangle the mess and rescue the data.Sigh.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202158</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>Anonymous</author>
	<datestamp>1266608760000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I think it would be instructive if you mentioned which industry you are in. Of the four programmers I knew before college, three have degrees. Two do embedded work, one works for THQ, and the other one makes ASP sites. Programming is a technical field, and going into it without an education severely limits the kind of work you are qualified to do.</p><p>I doubt that there are any gaps an educated programmer has that can't be filled with experience. But working grappling with messy codebases is an area which the HS grads will have at least a four year head start on, which needs to be taken into account.</p></htmltext>
<tokenext>I think it would be instructive if you mentioned which industry you are in .
Of the four programmers I knew before college , three have degrees .
Two do embedded work , one works for THQ , and the other one makes ASP sites .
Programming is a technical field , and going into it without an education severely limits the kind of work you are qualified to do.I doubt that there are any gaps an educated programmer has that ca n't be filled with experience .
But working grappling with messy codebases is an area which the HS grads will have at least a four year head start on , which needs to be taken into account .</tokentext>
<sentencetext>I think it would be instructive if you mentioned which industry you are in.
Of the four programmers I knew before college, three have degrees.
Two do embedded work, one works for THQ, and the other one makes ASP sites.
Programming is a technical field, and going into it without an education severely limits the kind of work you are qualified to do.I doubt that there are any gaps an educated programmer has that can't be filled with experience.
But working grappling with messy codebases is an area which the HS grads will have at least a four year head start on, which needs to be taken into account.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199902</id>
	<title>If you don't know where you've been...</title>
	<author>fmayhar</author>
	<datestamp>1266598080000</datestamp>
	<modclass>Informativ</modclass>
	<modscore>2</modscore>
	<htmltext><p>I've been doing this for a few years and the one gap I'm seeing more and more of doesn't actually have anything to do with programming techniques, "design patterns" or anything else that's hugely technical.  All of these things are pretty well-known and accepted by everyone, and you can always be sure that there'll be someone around pushing one or another of them as the be-all and end-all of Programming.</p><p>The one gap you might have as a self-taught programmer is in fact in the \_history\_ of computer science.  There's a lot of stuff that has happened and in fact people keep finding and solving the same problems, never realizing that the problems have been encountered and solved many times.  (An example that's particularly relevant to me at the moment has to do with extent-based file systems; ext4 has extents and so do a number of new file systems.  Great idea, right, particularly for large file systems?  Thing is, extent-based file systems have been used at least since the 70s in mainframe operating systems.  Odd that it took 40 years to get it into Unix.)</p><p>But don't feel bad that your self-teaching has skipped the history of computing.  It appears that most university computer science programs neglect that little bit of background as well, in favor of jumping straight into C++ or Java.</p><p>Maybe I'm an old fart but that half-semester of history I took back in 1981 made a small but significant improvement in my ability as a software engineer.</p></htmltext>
<tokenext>I 've been doing this for a few years and the one gap I 'm seeing more and more of does n't actually have anything to do with programming techniques , " design patterns " or anything else that 's hugely technical .
All of these things are pretty well-known and accepted by everyone , and you can always be sure that there 'll be someone around pushing one or another of them as the be-all and end-all of Programming.The one gap you might have as a self-taught programmer is in fact in the \ _history \ _ of computer science .
There 's a lot of stuff that has happened and in fact people keep finding and solving the same problems , never realizing that the problems have been encountered and solved many times .
( An example that 's particularly relevant to me at the moment has to do with extent-based file systems ; ext4 has extents and so do a number of new file systems .
Great idea , right , particularly for large file systems ?
Thing is , extent-based file systems have been used at least since the 70s in mainframe operating systems .
Odd that it took 40 years to get it into Unix .
) But do n't feel bad that your self-teaching has skipped the history of computing .
It appears that most university computer science programs neglect that little bit of background as well , in favor of jumping straight into C + + or Java.Maybe I 'm an old fart but that half-semester of history I took back in 1981 made a small but significant improvement in my ability as a software engineer .</tokentext>
<sentencetext>I've been doing this for a few years and the one gap I'm seeing more and more of doesn't actually have anything to do with programming techniques, "design patterns" or anything else that's hugely technical.
All of these things are pretty well-known and accepted by everyone, and you can always be sure that there'll be someone around pushing one or another of them as the be-all and end-all of Programming.The one gap you might have as a self-taught programmer is in fact in the \_history\_ of computer science.
There's a lot of stuff that has happened and in fact people keep finding and solving the same problems, never realizing that the problems have been encountered and solved many times.
(An example that's particularly relevant to me at the moment has to do with extent-based file systems; ext4 has extents and so do a number of new file systems.
Great idea, right, particularly for large file systems?
Thing is, extent-based file systems have been used at least since the 70s in mainframe operating systems.
Odd that it took 40 years to get it into Unix.
)But don't feel bad that your self-teaching has skipped the history of computing.
It appears that most university computer science programs neglect that little bit of background as well, in favor of jumping straight into C++ or Java.Maybe I'm an old fart but that half-semester of history I took back in 1981 made a small but significant improvement in my ability as a software engineer.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203696</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>bullok</author>
	<datestamp>1266572280000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext><p>This is an excellent list.  I was self-taught from the age of about 12, and thought I was an excellent programmer until I was about 25.  Having earned BS and MS degrees in Astronomy and Mathematics, I'd written a fair number of programs, and had a decent command of about 7 languages.   Then I went to graduate school for Computer Science.  And I found out that my knowledge was SEVERELY lacking, both in breadth and in depth.  How much of my missing knowledge was relevant to day-to-day programming tasks?   Well, perhaps not surprisingly, not much.  However, when I come across some issue where my CS education is useful, it's HUGELY useful, and enables me to tackle a problem in far less time, and most importantly, implement a correct solution.  It also lets me know when I need to turn over a portion of a project to a specialist.  In other words, I'm now more aware of the things that will become a time sink, and increase uncertainty if I attempt them.  This ability to do "project triage" is one of the benefits of a well-rounded CS education.</p><p>I think that this is the main reason that you'll hear a lot of people say that a university CS education isn't very useful.  For about 98\% of the things you work on, it really doesn't make you any better than someone who's self-taught.  But that remaining 2\%... it can mean the difference between blowing months of time on a crappy solution to a problem, or knowing how to put a good one together in a few days time.  So, on the whole, a Uni education can make you a far better programmer, even though you won't necessarily find yourself pulling tricks out of your Uni bag every day.</p><p>As an example I'll add my 2 cents about only one of the topics mentioned above:  Programming Languages.  There are many cases where programmers try to develop a "simple" scripting language for embedding in an application.  This is one thing that very few people (even uni-educated) should attempt.  Proper language design and parsing is VERY difficult, and there are at least a half-dozen well-designed scripting languages that can be literally dropped in to an application with almost no effort when compared to the complexity of rolling your own.  And yet, we see time and time again, people attempting to write one from scratch.  One of the worst examples I can think of off the top of my head is LSL (Linden Scripting Language), used in Second Life.  It's an absolute nightmare of a language.  And yet, it made it into a large-scale product like Second Life.</p><p>There ARE many cases where a domain-specific language (DSL) can be incredibly useful, especially when the language does not need to be a general-purpose one.  In my experience, it's rare for a programmer (no matter how their skills were gained), to create a good DSL without a strong grasp of at least a dozen programming languages or so.  University-educated programmers tend to be a better judge of whether they are up to the task of designing and/or implementing a language(at least, after they've tried their hand at it once or twice).</p></htmltext>
<tokenext>This is an excellent list .
I was self-taught from the age of about 12 , and thought I was an excellent programmer until I was about 25 .
Having earned BS and MS degrees in Astronomy and Mathematics , I 'd written a fair number of programs , and had a decent command of about 7 languages .
Then I went to graduate school for Computer Science .
And I found out that my knowledge was SEVERELY lacking , both in breadth and in depth .
How much of my missing knowledge was relevant to day-to-day programming tasks ?
Well , perhaps not surprisingly , not much .
However , when I come across some issue where my CS education is useful , it 's HUGELY useful , and enables me to tackle a problem in far less time , and most importantly , implement a correct solution .
It also lets me know when I need to turn over a portion of a project to a specialist .
In other words , I 'm now more aware of the things that will become a time sink , and increase uncertainty if I attempt them .
This ability to do " project triage " is one of the benefits of a well-rounded CS education.I think that this is the main reason that you 'll hear a lot of people say that a university CS education is n't very useful .
For about 98 \ % of the things you work on , it really does n't make you any better than someone who 's self-taught .
But that remaining 2 \ % ... it can mean the difference between blowing months of time on a crappy solution to a problem , or knowing how to put a good one together in a few days time .
So , on the whole , a Uni education can make you a far better programmer , even though you wo n't necessarily find yourself pulling tricks out of your Uni bag every day.As an example I 'll add my 2 cents about only one of the topics mentioned above : Programming Languages .
There are many cases where programmers try to develop a " simple " scripting language for embedding in an application .
This is one thing that very few people ( even uni-educated ) should attempt .
Proper language design and parsing is VERY difficult , and there are at least a half-dozen well-designed scripting languages that can be literally dropped in to an application with almost no effort when compared to the complexity of rolling your own .
And yet , we see time and time again , people attempting to write one from scratch .
One of the worst examples I can think of off the top of my head is LSL ( Linden Scripting Language ) , used in Second Life .
It 's an absolute nightmare of a language .
And yet , it made it into a large-scale product like Second Life.There ARE many cases where a domain-specific language ( DSL ) can be incredibly useful , especially when the language does not need to be a general-purpose one .
In my experience , it 's rare for a programmer ( no matter how their skills were gained ) , to create a good DSL without a strong grasp of at least a dozen programming languages or so .
University-educated programmers tend to be a better judge of whether they are up to the task of designing and/or implementing a language ( at least , after they 've tried their hand at it once or twice ) .</tokentext>
<sentencetext>This is an excellent list.
I was self-taught from the age of about 12, and thought I was an excellent programmer until I was about 25.
Having earned BS and MS degrees in Astronomy and Mathematics, I'd written a fair number of programs, and had a decent command of about 7 languages.
Then I went to graduate school for Computer Science.
And I found out that my knowledge was SEVERELY lacking, both in breadth and in depth.
How much of my missing knowledge was relevant to day-to-day programming tasks?
Well, perhaps not surprisingly, not much.
However, when I come across some issue where my CS education is useful, it's HUGELY useful, and enables me to tackle a problem in far less time, and most importantly, implement a correct solution.
It also lets me know when I need to turn over a portion of a project to a specialist.
In other words, I'm now more aware of the things that will become a time sink, and increase uncertainty if I attempt them.
This ability to do "project triage" is one of the benefits of a well-rounded CS education.I think that this is the main reason that you'll hear a lot of people say that a university CS education isn't very useful.
For about 98\% of the things you work on, it really doesn't make you any better than someone who's self-taught.
But that remaining 2\%... it can mean the difference between blowing months of time on a crappy solution to a problem, or knowing how to put a good one together in a few days time.
So, on the whole, a Uni education can make you a far better programmer, even though you won't necessarily find yourself pulling tricks out of your Uni bag every day.As an example I'll add my 2 cents about only one of the topics mentioned above:  Programming Languages.
There are many cases where programmers try to develop a "simple" scripting language for embedding in an application.
This is one thing that very few people (even uni-educated) should attempt.
Proper language design and parsing is VERY difficult, and there are at least a half-dozen well-designed scripting languages that can be literally dropped in to an application with almost no effort when compared to the complexity of rolling your own.
And yet, we see time and time again, people attempting to write one from scratch.
One of the worst examples I can think of off the top of my head is LSL (Linden Scripting Language), used in Second Life.
It's an absolute nightmare of a language.
And yet, it made it into a large-scale product like Second Life.There ARE many cases where a domain-specific language (DSL) can be incredibly useful, especially when the language does not need to be a general-purpose one.
In my experience, it's rare for a programmer (no matter how their skills were gained), to create a good DSL without a strong grasp of at least a dozen programming languages or so.
University-educated programmers tend to be a better judge of whether they are up to the task of designing and/or implementing a language(at least, after they've tried their hand at it once or twice).</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31208738</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>macs4all</author>
	<datestamp>1266659760000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p><div class="quote"><p>I might add to this list: Recursion.</p></div><p>I am a self-taught programmer, who was actually programming "out of my element" (I'm an embedded software/hardware dev. by trade), writing in C/AL (a 4th gen Pascal-like scripting language used in the financial/ERP package, Navision (now Microsoft Dynamics NAV), for the company I was working as an embedded dev. for at the time.<br> <br>
The task at hand was a function of do "exploding" of multi-level Bills of Materials (BOMs).<br> <br>
In about 3 lines of C/AL code, I designed and wrote a clean, recursive, data-driven function, that iterated down through the BOM levels. Worked perfectly the first time. I might add that I was also the "architect" on this project as well, so the "idea" of using a recursive function was my own as well, arrived at after about 10 minutes of "design analysis'.<br> <br>
By the way, even the experts at Navision had no idea that C/AL could even be used recursively, and they developed the language!<br> <br>
Moral to this story: A bad programmer is a bad programmer; conversely, a good programmer is a good programmer. Anything else is simply flapping of gums by all concerned (including me).<br> <br>
Incidentally, not only is my recursive "exploder" function still (since 1997) being used by my (now) former employer; but it also made its way into a paid "add-on" still being sold by a third-party Navision (MS NAV) developer.</p></div>
	</htmltext>
<tokenext>I might add to this list : Recursion.I am a self-taught programmer , who was actually programming " out of my element " ( I 'm an embedded software/hardware dev .
by trade ) , writing in C/AL ( a 4th gen Pascal-like scripting language used in the financial/ERP package , Navision ( now Microsoft Dynamics NAV ) , for the company I was working as an embedded dev .
for at the time .
The task at hand was a function of do " exploding " of multi-level Bills of Materials ( BOMs ) .
In about 3 lines of C/AL code , I designed and wrote a clean , recursive , data-driven function , that iterated down through the BOM levels .
Worked perfectly the first time .
I might add that I was also the " architect " on this project as well , so the " idea " of using a recursive function was my own as well , arrived at after about 10 minutes of " design analysis' .
By the way , even the experts at Navision had no idea that C/AL could even be used recursively , and they developed the language !
Moral to this story : A bad programmer is a bad programmer ; conversely , a good programmer is a good programmer .
Anything else is simply flapping of gums by all concerned ( including me ) .
Incidentally , not only is my recursive " exploder " function still ( since 1997 ) being used by my ( now ) former employer ; but it also made its way into a paid " add-on " still being sold by a third-party Navision ( MS NAV ) developer .</tokentext>
<sentencetext>I might add to this list: Recursion.I am a self-taught programmer, who was actually programming "out of my element" (I'm an embedded software/hardware dev.
by trade), writing in C/AL (a 4th gen Pascal-like scripting language used in the financial/ERP package, Navision (now Microsoft Dynamics NAV), for the company I was working as an embedded dev.
for at the time.
The task at hand was a function of do "exploding" of multi-level Bills of Materials (BOMs).
In about 3 lines of C/AL code, I designed and wrote a clean, recursive, data-driven function, that iterated down through the BOM levels.
Worked perfectly the first time.
I might add that I was also the "architect" on this project as well, so the "idea" of using a recursive function was my own as well, arrived at after about 10 minutes of "design analysis'.
By the way, even the experts at Navision had no idea that C/AL could even be used recursively, and they developed the language!
Moral to this story: A bad programmer is a bad programmer; conversely, a good programmer is a good programmer.
Anything else is simply flapping of gums by all concerned (including me).
Incidentally, not only is my recursive "exploder" function still (since 1997) being used by my (now) former employer; but it also made its way into a paid "add-on" still being sold by a third-party Navision (MS NAV) developer.
	</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200224</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200656</id>
	<title>Relational database design</title>
	<author>Anonymous</author>
	<datestamp>1266601320000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Heck, I think students who didn't opted for that RDBMS design class would design tables in complete different ways than one who does. For example, I tend to design and interpret tables with relationships (one-one, one-many, many-many) first, and then fill in the PK/FK later, while some colleagues just start with table and keys at the same time. Or, I can look at a set of tables designed by someone else and find that it makes no sense when you draw out the tables using "chicken feet" diagrams.</p></htmltext>
<tokenext>Heck , I think students who did n't opted for that RDBMS design class would design tables in complete different ways than one who does .
For example , I tend to design and interpret tables with relationships ( one-one , one-many , many-many ) first , and then fill in the PK/FK later , while some colleagues just start with table and keys at the same time .
Or , I can look at a set of tables designed by someone else and find that it makes no sense when you draw out the tables using " chicken feet " diagrams .</tokentext>
<sentencetext>Heck, I think students who didn't opted for that RDBMS design class would design tables in complete different ways than one who does.
For example, I tend to design and interpret tables with relationships (one-one, one-many, many-many) first, and then fill in the PK/FK later, while some colleagues just start with table and keys at the same time.
Or, I can look at a set of tables designed by someone else and find that it makes no sense when you draw out the tables using "chicken feet" diagrams.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31317692</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>eiro</author>
	<datestamp>1267464840000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Visit this link : How to become a programmer :

<a href="http://www.wikihow.com/Become-a-Programmer" title="wikihow.com" rel="nofollow">http://www.wikihow.com/Become-a-Programmer</a> [wikihow.com]</htmltext>
<tokenext>Visit this link : How to become a programmer : http : //www.wikihow.com/Become-a-Programmer [ wikihow.com ]</tokentext>
<sentencetext>Visit this link : How to become a programmer :

http://www.wikihow.com/Become-a-Programmer [wikihow.com]</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200232</id>
	<title>Grads don't necessarily grasp abstract concepts</title>
	<author>Anonymous</author>
	<datestamp>1266599640000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I can't say that people graduating have a good grasp of the more abstract concepts of  programing like polymorphism and recursion but they do get taught along with some of the more difficult data structures (B*Tree or Graphs).  I could also point to standards  documentation forms like UML relational diagrams, timing diagrams etc. </p><p>It really comes down to experience with real code for most things.</p></htmltext>
<tokenext>I ca n't say that people graduating have a good grasp of the more abstract concepts of programing like polymorphism and recursion but they do get taught along with some of the more difficult data structures ( B * Tree or Graphs ) .
I could also point to standards documentation forms like UML relational diagrams , timing diagrams etc .
It really comes down to experience with real code for most things .</tokentext>
<sentencetext>I can't say that people graduating have a good grasp of the more abstract concepts of  programing like polymorphism and recursion but they do get taught along with some of the more difficult data structures (B*Tree or Graphs).
I could also point to standards  documentation forms like UML relational diagrams, timing diagrams etc.
It really comes down to experience with real code for most things.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200140</id>
	<title>Things I found usefull</title>
	<author>utnapistim</author>
	<datestamp>1266599280000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Here are some things I found usefull in university:</p><p>- study of algorithms (big-O notation with case studies on sorting algorithms); This one completely changed the way I view program efficiency</p><p>- formal languages / compiler theory (grammars and parsing have never been the same for me since). This is something you will look at when you write any low-level parsing/validation: XML, functional / expression editors and even program parameters parsing in some cases.</p><p>- language classes (this was not the actual name of the course and I don't remember what it was actually), but we went through query languages (SQL), unstructured languages (BASIC), procedural and functional (C, pascal), OOP (CPP, java) and declarative (prolog). Prolog was something that made me see differently how the language changes the way you think about programming.</p><p>All that said, the academical medium has never been accused of being very practical minded, and I learned at least as much in working in programming as I learned in university. Don't dismiss one in favor of the other as each will show you things the other simply doesn't.</p></htmltext>
<tokenext>Here are some things I found usefull in university : - study of algorithms ( big-O notation with case studies on sorting algorithms ) ; This one completely changed the way I view program efficiency- formal languages / compiler theory ( grammars and parsing have never been the same for me since ) .
This is something you will look at when you write any low-level parsing/validation : XML , functional / expression editors and even program parameters parsing in some cases.- language classes ( this was not the actual name of the course and I do n't remember what it was actually ) , but we went through query languages ( SQL ) , unstructured languages ( BASIC ) , procedural and functional ( C , pascal ) , OOP ( CPP , java ) and declarative ( prolog ) .
Prolog was something that made me see differently how the language changes the way you think about programming.All that said , the academical medium has never been accused of being very practical minded , and I learned at least as much in working in programming as I learned in university .
Do n't dismiss one in favor of the other as each will show you things the other simply does n't .</tokentext>
<sentencetext>Here are some things I found usefull in university:- study of algorithms (big-O notation with case studies on sorting algorithms); This one completely changed the way I view program efficiency- formal languages / compiler theory (grammars and parsing have never been the same for me since).
This is something you will look at when you write any low-level parsing/validation: XML, functional / expression editors and even program parameters parsing in some cases.- language classes (this was not the actual name of the course and I don't remember what it was actually), but we went through query languages (SQL), unstructured languages (BASIC), procedural and functional (C, pascal), OOP (CPP, java) and declarative (prolog).
Prolog was something that made me see differently how the language changes the way you think about programming.All that said, the academical medium has never been accused of being very practical minded, and I learned at least as much in working in programming as I learned in university.
Don't dismiss one in favor of the other as each will show you things the other simply doesn't.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200108</id>
	<title>You haven't learned...</title>
	<author>Anonymous</author>
	<datestamp>1266599100000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>cynicism, hopelessness, futility, frustration, despair, indignation, indentured servitude, the gut wrenching emptiness that hits when a project you've poured your heart and soul into gets canned right when it's almost ready to release just because the ceo read some article about how everything should be done in some new sexy framework...</htmltext>
<tokenext>cynicism , hopelessness , futility , frustration , despair , indignation , indentured servitude , the gut wrenching emptiness that hits when a project you 've poured your heart and soul into gets canned right when it 's almost ready to release just because the ceo read some article about how everything should be done in some new sexy framework.. .</tokentext>
<sentencetext>cynicism, hopelessness, futility, frustration, despair, indignation, indentured servitude, the gut wrenching emptiness that hits when a project you've poured your heart and soul into gets canned right when it's almost ready to release just because the ceo read some article about how everything should be done in some new sexy framework...</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201818</id>
	<title>Comments, and Efficiency</title>
	<author>PerfectionLost</author>
	<datestamp>1266606600000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I think one thing schools teach is to comment.  In schools, comments are generally how you explain to your professor what you were doing.  In the work place, comments is how you explain to your co-workers, and predecessors what was going on in your mind.  It's also how you learn what your predecessors and co-workers were thinking when they wrote code you are inheriting.  Generally speaking , people who learn by them selves don't comment, because they don't expect anyone else to read their code.  Personally I find commenting a great way of explaining to myself how I am going to go about solving a problem as well.</p><p>The second big topic is efficiency.  Anyone can write code that gets the job done, but how efficient is the code you write?  Does your code complete in constant time, exponential, or logarithmic?  With small, low volume projects this doesn't matter, but how well your application scales to serving large numbers of people or utilizes vast quantities of data it matters immensely.  Google Big O for more information on this topic.</p><p>Finally at college you learn to use a lot of programming laguages, many of which you will never use again.  While you might think this is a wasted effort, it helps you learn how to learn new programming languages.  You seem to have a lot of programming languages under your belt, so you probably have this covered.</p></htmltext>
<tokenext>I think one thing schools teach is to comment .
In schools , comments are generally how you explain to your professor what you were doing .
In the work place , comments is how you explain to your co-workers , and predecessors what was going on in your mind .
It 's also how you learn what your predecessors and co-workers were thinking when they wrote code you are inheriting .
Generally speaking , people who learn by them selves do n't comment , because they do n't expect anyone else to read their code .
Personally I find commenting a great way of explaining to myself how I am going to go about solving a problem as well.The second big topic is efficiency .
Anyone can write code that gets the job done , but how efficient is the code you write ?
Does your code complete in constant time , exponential , or logarithmic ?
With small , low volume projects this does n't matter , but how well your application scales to serving large numbers of people or utilizes vast quantities of data it matters immensely .
Google Big O for more information on this topic.Finally at college you learn to use a lot of programming laguages , many of which you will never use again .
While you might think this is a wasted effort , it helps you learn how to learn new programming languages .
You seem to have a lot of programming languages under your belt , so you probably have this covered .</tokentext>
<sentencetext>I think one thing schools teach is to comment.
In schools, comments are generally how you explain to your professor what you were doing.
In the work place, comments is how you explain to your co-workers, and predecessors what was going on in your mind.
It's also how you learn what your predecessors and co-workers were thinking when they wrote code you are inheriting.
Generally speaking , people who learn by them selves don't comment, because they don't expect anyone else to read their code.
Personally I find commenting a great way of explaining to myself how I am going to go about solving a problem as well.The second big topic is efficiency.
Anyone can write code that gets the job done, but how efficient is the code you write?
Does your code complete in constant time, exponential, or logarithmic?
With small, low volume projects this doesn't matter, but how well your application scales to serving large numbers of people or utilizes vast quantities of data it matters immensely.
Google Big O for more information on this topic.Finally at college you learn to use a lot of programming laguages, many of which you will never use again.
While you might think this is a wasted effort, it helps you learn how to learn new programming languages.
You seem to have a lot of programming languages under your belt, so you probably have this covered.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31204024</id>
	<title>Some tips I can give you</title>
	<author>Anonymous</author>
	<datestamp>1266573600000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Get a good book on Algorithms and Data Structures. Then look at some Computer Science curriculums and work from their. (You can read some classic books like SICP, these should help)</p><p>Once you've done that you need to show you understand these things, maybe a portfolio of example code could help you here.</p><p>However, you're basically trying to prove that you're a Computer Scientist without a CS degree, in the long run you may want to study for a CS degree just for the accreditation.</p></htmltext>
<tokenext>Get a good book on Algorithms and Data Structures .
Then look at some Computer Science curriculums and work from their .
( You can read some classic books like SICP , these should help ) Once you 've done that you need to show you understand these things , maybe a portfolio of example code could help you here.However , you 're basically trying to prove that you 're a Computer Scientist without a CS degree , in the long run you may want to study for a CS degree just for the accreditation .</tokentext>
<sentencetext>Get a good book on Algorithms and Data Structures.
Then look at some Computer Science curriculums and work from their.
(You can read some classic books like SICP, these should help)Once you've done that you need to show you understand these things, maybe a portfolio of example code could help you here.However, you're basically trying to prove that you're a Computer Scientist without a CS degree, in the long run you may want to study for a CS degree just for the accreditation.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199556</id>
	<title>Everything</title>
	<author>Anonymous</author>
	<datestamp>1266596520000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Theory and practice of software development and computer science, plus whatever isn't covered by what i already mentioned.</p></htmltext>
<tokenext>Theory and practice of software development and computer science , plus whatever is n't covered by what i already mentioned .</tokentext>
<sentencetext>Theory and practice of software development and computer science, plus whatever isn't covered by what i already mentioned.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201630</id>
	<title>Re:Proper code analysis</title>
	<author>LordKazan</author>
	<datestamp>1266605700000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>"Can be picked up on your own" and "were picked up on your own" are rarely the same thing.  I was a self taught programmer until high school, where there was CS class (And later AP CS) taught by a former Apple Newton platform lead developer.   As a self taught, I was fairly typical from everything I read.</p><p>He took that raw talent, and enthusiasm, and turned them into real talent.</p><p>Are there truly wizard self taught programmers? Absolutely<br>Are most self taught programmers just practicing BFI? Absolutely.</p></htmltext>
<tokenext>" Can be picked up on your own " and " were picked up on your own " are rarely the same thing .
I was a self taught programmer until high school , where there was CS class ( And later AP CS ) taught by a former Apple Newton platform lead developer .
As a self taught , I was fairly typical from everything I read.He took that raw talent , and enthusiasm , and turned them into real talent.Are there truly wizard self taught programmers ?
AbsolutelyAre most self taught programmers just practicing BFI ?
Absolutely .</tokentext>
<sentencetext>"Can be picked up on your own" and "were picked up on your own" are rarely the same thing.
I was a self taught programmer until high school, where there was CS class (And later AP CS) taught by a former Apple Newton platform lead developer.
As a self taught, I was fairly typical from everything I read.He took that raw talent, and enthusiasm, and turned them into real talent.Are there truly wizard self taught programmers?
AbsolutelyAre most self taught programmers just practicing BFI?
Absolutely.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199868</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202400</id>
	<title>Math</title>
	<author>kenp2002</author>
	<datestamp>1266610380000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>Understanding Linear Algebra and Calculus allows for Mathematical solutions that can drastically cut down on the amount of coded recursion, looping, and needless flow control (if-then-else, case,select,switch,etc...)</p></htmltext>
<tokenext>Understanding Linear Algebra and Calculus allows for Mathematical solutions that can drastically cut down on the amount of coded recursion , looping , and needless flow control ( if-then-else , case,select,switch,etc... )</tokentext>
<sentencetext>Understanding Linear Algebra and Calculus allows for Mathematical solutions that can drastically cut down on the amount of coded recursion, looping, and needless flow control (if-then-else, case,select,switch,etc...)</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200922</id>
	<title>It depends on the student...</title>
	<author>Anonymous</author>
	<datestamp>1266602640000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>It really depends on the person and the exposure.  I've been writing code for more than 25 years and over that span I've developed projects in nearly every language/platform imaginable.  The young people I mentor and mange are not getting much benefit from college as I far as I can tell.  Most of the colleges seem to be behind in technology.  Being taught by professors that either have never worked in the field or did so 20 years ago and have lost touch with today's scene.  Most of my best employees have the hunger to learn.  It's not what they're learning in school, but what they're teaching themselves.  All anyone needs is a library card (or Google these days) and a strong desire to succeed.</p></htmltext>
<tokenext>It really depends on the person and the exposure .
I 've been writing code for more than 25 years and over that span I 've developed projects in nearly every language/platform imaginable .
The young people I mentor and mange are not getting much benefit from college as I far as I can tell .
Most of the colleges seem to be behind in technology .
Being taught by professors that either have never worked in the field or did so 20 years ago and have lost touch with today 's scene .
Most of my best employees have the hunger to learn .
It 's not what they 're learning in school , but what they 're teaching themselves .
All anyone needs is a library card ( or Google these days ) and a strong desire to succeed .</tokentext>
<sentencetext>It really depends on the person and the exposure.
I've been writing code for more than 25 years and over that span I've developed projects in nearly every language/platform imaginable.
The young people I mentor and mange are not getting much benefit from college as I far as I can tell.
Most of the colleges seem to be behind in technology.
Being taught by professors that either have never worked in the field or did so 20 years ago and have lost touch with today's scene.
Most of my best employees have the hunger to learn.
It's not what they're learning in school, but what they're teaching themselves.
All anyone needs is a library card (or Google these days) and a strong desire to succeed.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199566</id>
	<title>Some suggestions</title>
	<author>nicc777</author>
	<datestamp>1266596580000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>5</modscore>
	<htmltext>I was learning and coding on my own steam for about 15+ years. Then I joined the <a href="http://acm.org/" title="acm.org" rel="nofollow">ACM</a> [acm.org] (two years now) and my eyes opened. I am now about 1/3 though a B.Sc in CS (part time) and I'm also following a CPD program at another University. I have also joined the <a href="http://ieee.org/" title="ieee.org" rel="nofollow">IEEE</a> [ieee.org] as I required access to more material for my studies. What I realized was that I should have done it from the start. So my advice is simply this: start to follow some part time programs and get the theory as well. I have learned in the last two odd years a lot on subjects like modelling, quality assurance, frameworks and architectures which I otherwise would not have known. I also found that the quality of my code has greatly improved since I now work in a much more structured way.
<p>
Experience helps, but the real killer deal is experience backed by a CS/Eng. degree.</p></htmltext>
<tokenext>I was learning and coding on my own steam for about 15 + years .
Then I joined the ACM [ acm.org ] ( two years now ) and my eyes opened .
I am now about 1/3 though a B.Sc in CS ( part time ) and I 'm also following a CPD program at another University .
I have also joined the IEEE [ ieee.org ] as I required access to more material for my studies .
What I realized was that I should have done it from the start .
So my advice is simply this : start to follow some part time programs and get the theory as well .
I have learned in the last two odd years a lot on subjects like modelling , quality assurance , frameworks and architectures which I otherwise would not have known .
I also found that the quality of my code has greatly improved since I now work in a much more structured way .
Experience helps , but the real killer deal is experience backed by a CS/Eng .
degree .</tokentext>
<sentencetext>I was learning and coding on my own steam for about 15+ years.
Then I joined the ACM [acm.org] (two years now) and my eyes opened.
I am now about 1/3 though a B.Sc in CS (part time) and I'm also following a CPD program at another University.
I have also joined the IEEE [ieee.org] as I required access to more material for my studies.
What I realized was that I should have done it from the start.
So my advice is simply this: start to follow some part time programs and get the theory as well.
I have learned in the last two odd years a lot on subjects like modelling, quality assurance, frameworks and architectures which I otherwise would not have known.
I also found that the quality of my code has greatly improved since I now work in a much more structured way.
Experience helps, but the real killer deal is experience backed by a CS/Eng.
degree.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200412</id>
	<title>Project management, no doubt.</title>
	<author>Anonymous</author>
	<datestamp>1266600360000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>As you, I am a self-taught programmer. I started at young age with a ZX Spectrum 48K, and after finishing high school, I had the good luck to have an opportunity to work at a software house as a programmer. I know now that what I knew about programming at that time was really close to nothing. Currently, I "write code" for a living as a freelance professional (though what I actually "sell" is always an end product or service to meet specific needs).<br>What I learned through the years by experience, is that the practice of project management is crucial when writing code and has an enormous impact on the end product's quality and meeting deadlines. The fact that a person has developed the habit of looking at a project (no matter how small) from a top level perspective makes him or her make better decisions when writing code or designing models.<br>Getting the work done and well done, in time and within the budget is always all that matters. That's why I believe that PM is the most important discipline for any programmer, much more than being highly specialized in a specific technology or area. It gives the individual the ability to see the whole, articulate better with other collaborators, understand the ramifications of his decisions and the purposiveness of his work.</p></htmltext>
<tokenext>As you , I am a self-taught programmer .
I started at young age with a ZX Spectrum 48K , and after finishing high school , I had the good luck to have an opportunity to work at a software house as a programmer .
I know now that what I knew about programming at that time was really close to nothing .
Currently , I " write code " for a living as a freelance professional ( though what I actually " sell " is always an end product or service to meet specific needs ) .What I learned through the years by experience , is that the practice of project management is crucial when writing code and has an enormous impact on the end product 's quality and meeting deadlines .
The fact that a person has developed the habit of looking at a project ( no matter how small ) from a top level perspective makes him or her make better decisions when writing code or designing models.Getting the work done and well done , in time and within the budget is always all that matters .
That 's why I believe that PM is the most important discipline for any programmer , much more than being highly specialized in a specific technology or area .
It gives the individual the ability to see the whole , articulate better with other collaborators , understand the ramifications of his decisions and the purposiveness of his work .</tokentext>
<sentencetext>As you, I am a self-taught programmer.
I started at young age with a ZX Spectrum 48K, and after finishing high school, I had the good luck to have an opportunity to work at a software house as a programmer.
I know now that what I knew about programming at that time was really close to nothing.
Currently, I "write code" for a living as a freelance professional (though what I actually "sell" is always an end product or service to meet specific needs).What I learned through the years by experience, is that the practice of project management is crucial when writing code and has an enormous impact on the end product's quality and meeting deadlines.
The fact that a person has developed the habit of looking at a project (no matter how small) from a top level perspective makes him or her make better decisions when writing code or designing models.Getting the work done and well done, in time and within the budget is always all that matters.
That's why I believe that PM is the most important discipline for any programmer, much more than being highly specialized in a specific technology or area.
It gives the individual the ability to see the whole, articulate better with other collaborators, understand the ramifications of his decisions and the purposiveness of his work.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200160</id>
	<title>Passion</title>
	<author>N0t4v41l4bl3</author>
	<datestamp>1266599340000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext>Self-taught = passionate = "talent" not teachable in class

I know who I'd rather hire</htmltext>
<tokenext>Self-taught = passionate = " talent " not teachable in class I know who I 'd rather hire</tokentext>
<sentencetext>Self-taught = passionate = "talent" not teachable in class

I know who I'd rather hire</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31212800</id>
	<title>Code Complete</title>
	<author>minstrelmike</author>
	<datestamp>1266658740000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Get the book "Code Complete." I started reading it after a survey in ComputerWeek or TechRepublic asked what the best programing book was. They chose that one.<br> <br>It covers real world programing, issues over commenting and variable names and standards and conventions vs getting things done vs maintenance down the road.</htmltext>
<tokenext>Get the book " Code Complete .
" I started reading it after a survey in ComputerWeek or TechRepublic asked what the best programing book was .
They chose that one .
It covers real world programing , issues over commenting and variable names and standards and conventions vs getting things done vs maintenance down the road .</tokentext>
<sentencetext>Get the book "Code Complete.
" I started reading it after a survey in ComputerWeek or TechRepublic asked what the best programing book was.
They chose that one.
It covers real world programing, issues over commenting and variable names and standards and conventions vs getting things done vs maintenance down the road.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199864</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>Anonymous</author>
	<datestamp>1266597960000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I would agree with most of it except for the design patterns. In my earlier workplace I had a horrible time rewriting ("refactoring") codes left by the former "Software Architect" who sprinkled design pattern wonders all over his Java codes.</p><p>The classes were all abstract! Without methods! For 3 or 4 layers! All without methods!</p><p>For your information I am an algorithms major, PhD, and consider myself a theoretical computer scientist. Our kinds don't get along with those "Software Architects". I would appreciate it if you don't list our methods with "Design Patterns".</p></htmltext>
<tokenext>I would agree with most of it except for the design patterns .
In my earlier workplace I had a horrible time rewriting ( " refactoring " ) codes left by the former " Software Architect " who sprinkled design pattern wonders all over his Java codes.The classes were all abstract !
Without methods !
For 3 or 4 layers !
All without methods ! For your information I am an algorithms major , PhD , and consider myself a theoretical computer scientist .
Our kinds do n't get along with those " Software Architects " .
I would appreciate it if you do n't list our methods with " Design Patterns " .</tokentext>
<sentencetext>I would agree with most of it except for the design patterns.
In my earlier workplace I had a horrible time rewriting ("refactoring") codes left by the former "Software Architect" who sprinkled design pattern wonders all over his Java codes.The classes were all abstract!
Without methods!
For 3 or 4 layers!
All without methods!For your information I am an algorithms major, PhD, and consider myself a theoretical computer scientist.
Our kinds don't get along with those "Software Architects".
I would appreciate it if you don't list our methods with "Design Patterns".</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199850</id>
	<title>algorithms, code design, proper use of objects</title>
	<author>Satis</author>
	<datestamp>1266597900000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I am/was self taught as well, mostly web-based to start with... PHP, then javascript, then C# over many years and up to using OO in all three.  A year ago I started taking c++ classes in college and I can say I picked up a few very helpful things.</p><p>1. C++ gave me a look into pointers and how stuff runs at a lower level than any of the other languages.<br>2. Object use.  I used objects before, but I didn't leverage them quite as heavily as I could have, including inheritance and polymorphism.  What I learned in C++ has greatly affected how I code in PHP and C#.<br>3. One of my C++ classes was about efficiency in algorithms... so I learned a bunch about how stuff is done deep down and how to write efficient code.  Very helpful for some of the stuff I do in PHP and javascript when working with large data sets.<br>4.  Code design is a big one... before, I just put all my methods into a single class and called them there.  The class ended up being more of a repository for functions and data than a real class.  Now I have a better grasp of breaking stuff into parts and either creating child classes or whatever is appropriate.</p><p>It's still a learning process.  I'm only on my 4th c++ class and haven't even taken the data structure class yet, but I've learned a tremendous amount, even in just the first intro to c++ class.  My suggestion... take at least intro to c++ at a community college.. you'll probably be surprised how much you'll learn.  As an added bonus, being familiar with programming makes getting an A a breeze, so you can concentrate on actually writing decent code and learning stuff.</p></htmltext>
<tokenext>I am/was self taught as well , mostly web-based to start with... PHP , then javascript , then C # over many years and up to using OO in all three .
A year ago I started taking c + + classes in college and I can say I picked up a few very helpful things.1 .
C + + gave me a look into pointers and how stuff runs at a lower level than any of the other languages.2 .
Object use .
I used objects before , but I did n't leverage them quite as heavily as I could have , including inheritance and polymorphism .
What I learned in C + + has greatly affected how I code in PHP and C # .3 .
One of my C + + classes was about efficiency in algorithms... so I learned a bunch about how stuff is done deep down and how to write efficient code .
Very helpful for some of the stuff I do in PHP and javascript when working with large data sets.4 .
Code design is a big one... before , I just put all my methods into a single class and called them there .
The class ended up being more of a repository for functions and data than a real class .
Now I have a better grasp of breaking stuff into parts and either creating child classes or whatever is appropriate.It 's still a learning process .
I 'm only on my 4th c + + class and have n't even taken the data structure class yet , but I 've learned a tremendous amount , even in just the first intro to c + + class .
My suggestion... take at least intro to c + + at a community college.. you 'll probably be surprised how much you 'll learn .
As an added bonus , being familiar with programming makes getting an A a breeze , so you can concentrate on actually writing decent code and learning stuff .</tokentext>
<sentencetext>I am/was self taught as well, mostly web-based to start with... PHP, then javascript, then C# over many years and up to using OO in all three.
A year ago I started taking c++ classes in college and I can say I picked up a few very helpful things.1.
C++ gave me a look into pointers and how stuff runs at a lower level than any of the other languages.2.
Object use.
I used objects before, but I didn't leverage them quite as heavily as I could have, including inheritance and polymorphism.
What I learned in C++ has greatly affected how I code in PHP and C#.3.
One of my C++ classes was about efficiency in algorithms... so I learned a bunch about how stuff is done deep down and how to write efficient code.
Very helpful for some of the stuff I do in PHP and javascript when working with large data sets.4.
Code design is a big one... before, I just put all my methods into a single class and called them there.
The class ended up being more of a repository for functions and data than a real class.
Now I have a better grasp of breaking stuff into parts and either creating child classes or whatever is appropriate.It's still a learning process.
I'm only on my 4th c++ class and haven't even taken the data structure class yet, but I've learned a tremendous amount, even in just the first intro to c++ class.
My suggestion... take at least intro to c++ at a community college.. you'll probably be surprised how much you'll learn.
As an added bonus, being familiar with programming makes getting an A a breeze, so you can concentrate on actually writing decent code and learning stuff.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31221388</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>thePowerOfGrayskull</author>
	<datestamp>1266743460000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>These are all areas of weakness I've seen in university-taught programmers too.  That's more a result of the general lowering of standards that our industry underwent in the 90s.</htmltext>
<tokenext>These are all areas of weakness I 've seen in university-taught programmers too .
That 's more a result of the general lowering of standards that our industry underwent in the 90s .</tokentext>
<sentencetext>These are all areas of weakness I've seen in university-taught programmers too.
That's more a result of the general lowering of standards that our industry underwent in the 90s.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31206314</id>
	<title>Hash tables</title>
	<author>Anonymous</author>
	<datestamp>1266585180000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>After about 10 years of learning by just reading specs and figuring things out on my own I began a study. And that's when I heard about hash tables the first time. I would have never come up with hash tables on my own. It was like they were introducing in something occult.</p><p>Finding the desired record in giant amounts of data INSTANTLY on average.</p></htmltext>
<tokenext>After about 10 years of learning by just reading specs and figuring things out on my own I began a study .
And that 's when I heard about hash tables the first time .
I would have never come up with hash tables on my own .
It was like they were introducing in something occult.Finding the desired record in giant amounts of data INSTANTLY on average .</tokentext>
<sentencetext>After about 10 years of learning by just reading specs and figuring things out on my own I began a study.
And that's when I heard about hash tables the first time.
I would have never come up with hash tables on my own.
It was like they were introducing in something occult.Finding the desired record in giant amounts of data INSTANTLY on average.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202366</id>
	<title>There are all kinds</title>
	<author>agentultra</author>
	<datestamp>1266610200000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I'm a self-taught programmer.</p><p>I know algorithms, complexity theory, and lots of math: linear algebra, discrete maths, etc.</p><p>What does a good programmer need to know though? Fundamentals. Everything else is specialization. You'll need to know hardware, compilers, interpreters; abstractions, and a solid foundation in scientific principles. You need to be able to hypothesize, implement, test, and evaluate. A basic understanding of algorithms and complexity theory naturally comes into play when theorizing about computer problems which is why most courses integrate them into the curriculum. Beyond a very principled but fundamental understanding however, an in-depth and broad education in such subjects isn't necessary.</p><p>I taught myself a lot of maths because that's what interests me. I wanted to know how to write ray tracers, how to optimize them; how to use statistical analysis and discreet mathematics to sort through and find interesting facts about large sets of data. Do I need to know any of that to write a piece of software, compile it, and have it run efficiently? No. I learned that stuff for the kinds of programs I was writing.</p><p>The only real difference I find between myself and my university-trained colleagues is that I haven't suffered under the same financial burden as they for the knowledge I've acquired. Yet they talk about it like it's a serious advantage! Of course, there really isn't a serious difference between us that matters when the software ships. It's just a matter of perspective.</p><p>The stigma engendered to self-taught programmers however, is the hurdle I find most difficult to overcome and also easiest to ignore. Difficult because people assume things about you when you tell them that you learned on your own. Easy because once they realize that you are competent and capable, the stigma is removed. What many people don't seem to realize is that there are some great programmers out there who were self-taught. Just read through some of the interviews in "Coders at Work" by Peter Siebel. If the autodidacts among us are to be taken seriously, this generalization that self-taught programmers are backyard hacks has to stop. A bad programmer is a bad programmer whether they are self-taught or university taught.</p><p>After all, I could just turn around and generalize by saying that university trained programmers are privileged snobs who think "real-world" programming is beneath them. But that wouldn't be fair would it?</p><p>It takes all kinds and to each their own.</p><p>If you think you need to know something to solve the problem you're having, learn it. Move on.</p></htmltext>
<tokenext>I 'm a self-taught programmer.I know algorithms , complexity theory , and lots of math : linear algebra , discrete maths , etc.What does a good programmer need to know though ?
Fundamentals. Everything else is specialization .
You 'll need to know hardware , compilers , interpreters ; abstractions , and a solid foundation in scientific principles .
You need to be able to hypothesize , implement , test , and evaluate .
A basic understanding of algorithms and complexity theory naturally comes into play when theorizing about computer problems which is why most courses integrate them into the curriculum .
Beyond a very principled but fundamental understanding however , an in-depth and broad education in such subjects is n't necessary.I taught myself a lot of maths because that 's what interests me .
I wanted to know how to write ray tracers , how to optimize them ; how to use statistical analysis and discreet mathematics to sort through and find interesting facts about large sets of data .
Do I need to know any of that to write a piece of software , compile it , and have it run efficiently ?
No. I learned that stuff for the kinds of programs I was writing.The only real difference I find between myself and my university-trained colleagues is that I have n't suffered under the same financial burden as they for the knowledge I 've acquired .
Yet they talk about it like it 's a serious advantage !
Of course , there really is n't a serious difference between us that matters when the software ships .
It 's just a matter of perspective.The stigma engendered to self-taught programmers however , is the hurdle I find most difficult to overcome and also easiest to ignore .
Difficult because people assume things about you when you tell them that you learned on your own .
Easy because once they realize that you are competent and capable , the stigma is removed .
What many people do n't seem to realize is that there are some great programmers out there who were self-taught .
Just read through some of the interviews in " Coders at Work " by Peter Siebel .
If the autodidacts among us are to be taken seriously , this generalization that self-taught programmers are backyard hacks has to stop .
A bad programmer is a bad programmer whether they are self-taught or university taught.After all , I could just turn around and generalize by saying that university trained programmers are privileged snobs who think " real-world " programming is beneath them .
But that would n't be fair would it ? It takes all kinds and to each their own.If you think you need to know something to solve the problem you 're having , learn it .
Move on .</tokentext>
<sentencetext>I'm a self-taught programmer.I know algorithms, complexity theory, and lots of math: linear algebra, discrete maths, etc.What does a good programmer need to know though?
Fundamentals. Everything else is specialization.
You'll need to know hardware, compilers, interpreters; abstractions, and a solid foundation in scientific principles.
You need to be able to hypothesize, implement, test, and evaluate.
A basic understanding of algorithms and complexity theory naturally comes into play when theorizing about computer problems which is why most courses integrate them into the curriculum.
Beyond a very principled but fundamental understanding however, an in-depth and broad education in such subjects isn't necessary.I taught myself a lot of maths because that's what interests me.
I wanted to know how to write ray tracers, how to optimize them; how to use statistical analysis and discreet mathematics to sort through and find interesting facts about large sets of data.
Do I need to know any of that to write a piece of software, compile it, and have it run efficiently?
No. I learned that stuff for the kinds of programs I was writing.The only real difference I find between myself and my university-trained colleagues is that I haven't suffered under the same financial burden as they for the knowledge I've acquired.
Yet they talk about it like it's a serious advantage!
Of course, there really isn't a serious difference between us that matters when the software ships.
It's just a matter of perspective.The stigma engendered to self-taught programmers however, is the hurdle I find most difficult to overcome and also easiest to ignore.
Difficult because people assume things about you when you tell them that you learned on your own.
Easy because once they realize that you are competent and capable, the stigma is removed.
What many people don't seem to realize is that there are some great programmers out there who were self-taught.
Just read through some of the interviews in "Coders at Work" by Peter Siebel.
If the autodidacts among us are to be taken seriously, this generalization that self-taught programmers are backyard hacks has to stop.
A bad programmer is a bad programmer whether they are self-taught or university taught.After all, I could just turn around and generalize by saying that university trained programmers are privileged snobs who think "real-world" programming is beneath them.
But that wouldn't be fair would it?It takes all kinds and to each their own.If you think you need to know something to solve the problem you're having, learn it.
Move on.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200194</id>
	<title>Fundamental CS, algorithms etc.</title>
	<author>Anonymous</author>
	<datestamp>1266599520000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>Self taught also, Mechanical Engineer by training.  I've found my biggest gap to be fundamental CS stuff, I'm currently working my way through a book on algorithms:

<a href="http://www.amazon.com/Introduction-Algorithms-Third-Thomas-Cormen/dp/0262033844/ref=sr\_1\_1?ie=UTF8&amp;s=books&amp;qid=1266595707&amp;sr=8-1" title="amazon.com" rel="nofollow">http://www.amazon.com/Introduction-Algorithms-Third-Thomas-Cormen/dp/0262033844/ref=sr\_1\_1?ie=UTF8&amp;s=books&amp;qid=1266595707&amp;sr=8-1</a> [amazon.com]

While the practical implications of knowing this stuff is limited, it's always good to have a deeper understanding, and it will help if you're ever in an interview with hard core CS types.</htmltext>
<tokenext>Self taught also , Mechanical Engineer by training .
I 've found my biggest gap to be fundamental CS stuff , I 'm currently working my way through a book on algorithms : http : //www.amazon.com/Introduction-Algorithms-Third-Thomas-Cormen/dp/0262033844/ref = sr \ _1 \ _1 ? ie = UTF8&amp;s = books&amp;qid = 1266595707&amp;sr = 8-1 [ amazon.com ] While the practical implications of knowing this stuff is limited , it 's always good to have a deeper understanding , and it will help if you 're ever in an interview with hard core CS types .</tokentext>
<sentencetext>Self taught also, Mechanical Engineer by training.
I've found my biggest gap to be fundamental CS stuff, I'm currently working my way through a book on algorithms:

http://www.amazon.com/Introduction-Algorithms-Third-Thomas-Cormen/dp/0262033844/ref=sr\_1\_1?ie=UTF8&amp;s=books&amp;qid=1266595707&amp;sr=8-1 [amazon.com]

While the practical implications of knowing this stuff is limited, it's always good to have a deeper understanding, and it will help if you're ever in an interview with hard core CS types.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203570</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>Anonymous</author>
	<datestamp>1266571860000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>Databases.</p></htmltext>
<tokenext>Databases .</tokentext>
<sentencetext>Databases.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31205000</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>SoftwareArtist</author>
	<datestamp>1266577620000</datestamp>
	<modclass>Insightful</modclass>
	<modscore>2</modscore>
	<htmltext>My experience is that the best predictor of programming ability (among professional programmers) is whether someone learned to program <i>before</i> college.  The best programmers are the people who were introduced to programming when they were 10 and fell in love with it, not the people who got to college, decided CS seemed like a good career path, and so took an intro programming class.  If you love doing something, you'll learn to do it well, and if you just see it as a job, you likely won't.  In fact, the biggest problem with many CS majors is that they <i>think</i> they know how to program well, not realizing that computer science and software engineering are actually very different subjects.
<br> <br>
That said, self taught programmers definitely have holes they need to fill.  Lots of other people have said this already but I'll add yet another vote for it: algorithms and data structures.  Get a good book on them.  Learn them.  This is bread and butter stuff that a professional programmer really needs to understand, and if you haven't studied it, you probably don't realize just how much you don't know.</htmltext>
<tokenext>My experience is that the best predictor of programming ability ( among professional programmers ) is whether someone learned to program before college .
The best programmers are the people who were introduced to programming when they were 10 and fell in love with it , not the people who got to college , decided CS seemed like a good career path , and so took an intro programming class .
If you love doing something , you 'll learn to do it well , and if you just see it as a job , you likely wo n't .
In fact , the biggest problem with many CS majors is that they think they know how to program well , not realizing that computer science and software engineering are actually very different subjects .
That said , self taught programmers definitely have holes they need to fill .
Lots of other people have said this already but I 'll add yet another vote for it : algorithms and data structures .
Get a good book on them .
Learn them .
This is bread and butter stuff that a professional programmer really needs to understand , and if you have n't studied it , you probably do n't realize just how much you do n't know .</tokentext>
<sentencetext>My experience is that the best predictor of programming ability (among professional programmers) is whether someone learned to program before college.
The best programmers are the people who were introduced to programming when they were 10 and fell in love with it, not the people who got to college, decided CS seemed like a good career path, and so took an intro programming class.
If you love doing something, you'll learn to do it well, and if you just see it as a job, you likely won't.
In fact, the biggest problem with many CS majors is that they think they know how to program well, not realizing that computer science and software engineering are actually very different subjects.
That said, self taught programmers definitely have holes they need to fill.
Lots of other people have said this already but I'll add yet another vote for it: algorithms and data structures.
Get a good book on them.
Learn them.
This is bread and butter stuff that a professional programmer really needs to understand, and if you haven't studied it, you probably don't realize just how much you don't know.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199722</id>
	<title>Organisation, Algorithms</title>
	<author>Anonymous</author>
	<datestamp>1266597360000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>I think my biggest problem with being a self-taught programmer, is not really knowing how to organise code into physical files so that it makes sense, and when is it a good time to commit ones code to version control, and should one branch to do this or do it on the main branch.</p><p>I guess I'm also lacking some of the standard algorithms, as a self taught programmer I started out by coding to solve some real world problem I had rather than some contrived exercises involving how to code the basic algorithms such as linked lists, stacked based recursion and recursive algorithms</p></htmltext>
<tokenext>I think my biggest problem with being a self-taught programmer , is not really knowing how to organise code into physical files so that it makes sense , and when is it a good time to commit ones code to version control , and should one branch to do this or do it on the main branch.I guess I 'm also lacking some of the standard algorithms , as a self taught programmer I started out by coding to solve some real world problem I had rather than some contrived exercises involving how to code the basic algorithms such as linked lists , stacked based recursion and recursive algorithms</tokentext>
<sentencetext>I think my biggest problem with being a self-taught programmer, is not really knowing how to organise code into physical files so that it makes sense, and when is it a good time to commit ones code to version control, and should one branch to do this or do it on the main branch.I guess I'm also lacking some of the standard algorithms, as a self taught programmer I started out by coding to solve some real world problem I had rather than some contrived exercises involving how to code the basic algorithms such as linked lists, stacked based recursion and recursive algorithms</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199538</id>
	<title>Purple Monkey</title>
	<author>Anonymous</author>
	<datestamp>1266596520000</datestamp>
	<modclass>None</modclass>
	<modscore>0</modscore>
	<htmltext><p>you can be a self taught coder.</p><p>but to be a Software Developer you need to study for years, and build upon it with experience.</p><p>like people before me said, design patterns, modelling, and algorithms.</p><p>I've worked with both, and you can tell.</p></htmltext>
<tokenext>you can be a self taught coder.but to be a Software Developer you need to study for years , and build upon it with experience.like people before me said , design patterns , modelling , and algorithms.I 've worked with both , and you can tell .</tokentext>
<sentencetext>you can be a self taught coder.but to be a Software Developer you need to study for years, and build upon it with experience.like people before me said, design patterns, modelling, and algorithms.I've worked with both, and you can tell.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200224</id>
	<title>Re:DP, Algorithms, OOP A&amp;D, Threading, etc</title>
	<author>ubersoldat2k7</author>
	<datestamp>1266599580000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext>I might add to this list: Recursion.</htmltext>
<tokenext>I might add to this list : Recursion .</tokentext>
<sentencetext>I might add to this list: Recursion.</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203626</id>
	<title>Exposure to different styles of programming</title>
	<author>mbessey</author>
	<datestamp>1266572040000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>&gt; I have taught myself C++, Java, python, PHP, etc</p><p>Depending on how deeply you "know" each of those languages, you may be lacking experience in some very different ways of doing things. You ought to at least add one functional language (Scheme or Haskell), and do some really low-level programming (in assembly language, or C). If you haven't looked into C++ templates yet, that is another very different paradigm worth learning.</p></htmltext>
<tokenext>&gt; I have taught myself C + + , Java , python , PHP , etcDepending on how deeply you " know " each of those languages , you may be lacking experience in some very different ways of doing things .
You ought to at least add one functional language ( Scheme or Haskell ) , and do some really low-level programming ( in assembly language , or C ) .
If you have n't looked into C + + templates yet , that is another very different paradigm worth learning .</tokentext>
<sentencetext>&gt; I have taught myself C++, Java, python, PHP, etcDepending on how deeply you "know" each of those languages, you may be lacking experience in some very different ways of doing things.
You ought to at least add one functional language (Scheme or Haskell), and do some really low-level programming (in assembly language, or C).
If you haven't looked into C++ templates yet, that is another very different paradigm worth learning.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200248</id>
	<title>Functional Programming and Complexity Theory</title>
	<author>Lemming Mark</author>
	<datestamp>1266599760000</datestamp>
	<modclass>Interestin</modclass>
	<modscore>2</modscore>
	<htmltext><p>You almost certainly already have some grasp of Complexity Theory since it governs why e.g. mergesort is faster than bubblesort.  I personally found it a somewhat dull topic but it is probably worth delving into a bit for "self improvement" purposes.</p><p>Functional programming is worth playing around with.  US universities tend to focus on Lisp, I think.  ML and Haskell are often used in the UK and have a very interesting type system (proponents say that it's about the most advanced one out there) that it's also worth being aware of.  Haskell is also a lazy language, which is interesting although you're unlikely to encounter it anywhere else!  Some of my ML programming course dealt with how to build lazy data structures without explicit language support, which was potentially a useful technique.</p><p>Others have mentioned design patterns.  I guess it's worth looking at those since even though you might instinctively know some, it's easier in an interview if you can *name* them so they know you know what you're talking about.</p></htmltext>
<tokenext>You almost certainly already have some grasp of Complexity Theory since it governs why e.g .
mergesort is faster than bubblesort .
I personally found it a somewhat dull topic but it is probably worth delving into a bit for " self improvement " purposes.Functional programming is worth playing around with .
US universities tend to focus on Lisp , I think .
ML and Haskell are often used in the UK and have a very interesting type system ( proponents say that it 's about the most advanced one out there ) that it 's also worth being aware of .
Haskell is also a lazy language , which is interesting although you 're unlikely to encounter it anywhere else !
Some of my ML programming course dealt with how to build lazy data structures without explicit language support , which was potentially a useful technique.Others have mentioned design patterns .
I guess it 's worth looking at those since even though you might instinctively know some , it 's easier in an interview if you can * name * them so they know you know what you 're talking about .</tokentext>
<sentencetext>You almost certainly already have some grasp of Complexity Theory since it governs why e.g.
mergesort is faster than bubblesort.
I personally found it a somewhat dull topic but it is probably worth delving into a bit for "self improvement" purposes.Functional programming is worth playing around with.
US universities tend to focus on Lisp, I think.
ML and Haskell are often used in the UK and have a very interesting type system (proponents say that it's about the most advanced one out there) that it's also worth being aware of.
Haskell is also a lazy language, which is interesting although you're unlikely to encounter it anywhere else!
Some of my ML programming course dealt with how to build lazy data structures without explicit language support, which was potentially a useful technique.Others have mentioned design patterns.
I guess it's worth looking at those since even though you might instinctively know some, it's easier in an interview if you can *name* them so they know you know what you're talking about.</sentencetext>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200372</id>
	<title>Re:I'm Interested in the Opposite View</title>
	<author>BadKneeDad</author>
	<datestamp>1266600240000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>In my experience, it is a gut feeling of how to get something done. CS majors tend to design for days while the self taught tends to get it done, tested and moves on to the next thing. This can be a problem with large code bases; although the CS major can also stumble here as well.</p><p>A balance between the two is nice!</p></htmltext>
<tokenext>In my experience , it is a gut feeling of how to get something done .
CS majors tend to design for days while the self taught tends to get it done , tested and moves on to the next thing .
This can be a problem with large code bases ; although the CS major can also stumble here as well.A balance between the two is nice !</tokentext>
<sentencetext>In my experience, it is a gut feeling of how to get something done.
CS majors tend to design for days while the self taught tends to get it done, tested and moves on to the next thing.
This can be a problem with large code bases; although the CS major can also stumble here as well.A balance between the two is nice!</sentencetext>
	<parent>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704</parent>
</comment>
<comment>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31278856</id>
	<title>Science and Engineering</title>
	<author>turgid</author>
	<datestamp>1267097160000</datestamp>
	<modclass>None</modclass>
	<modscore>1</modscore>
	<htmltext><p>I come from a very similar background to yours and am largely self-taught as well.
</p><p>As far as Computer Science goes, the important things in addition to what you have already studied are Algorithms (Knuth, Sedgewick) and Functional Programming (scheme is nice and simple and mature). I wish I'd known about Functional Programming 20 years ago...
</p><p>In the world of work, if you understand and can implement basic algorithms in C and C++ you will be miles ahead of 90\% of people.
</p><p>What's really important for work is good engineering practice. You should learn about design and testing. Test Driven Development is a really powerful technique and quite easy to pick up if you are a hands-on learner. Your code will be so much better as a result. Again. you'll be miles ahead of most other people.
</p><p>Learn about Combinatorial Testing. See the NIST website.
</p><p>Do code reviews. Review code written by people better and more experienced than yourself. That's a very powerful way to learn what works and good style.
</p><p>Befriend some grey-beards and heed their words.
</p><p>Continuous integration, refactoring,<nobr> <wbr></nobr>... it's a lifetime's challenge but it's great fun and very rewarding.
</p><p>Finally, knowing Bourne shell (or bash) scripting is as very useful skill to have. It opens many doors and can make you a very valuable team member since many people only know GUI tools (Visual Studio).
</p><p>Don't over-emphasise the PHP. It leads to dead-end jobs that are way beneath you.</p></htmltext>
<tokenext>I come from a very similar background to yours and am largely self-taught as well .
As far as Computer Science goes , the important things in addition to what you have already studied are Algorithms ( Knuth , Sedgewick ) and Functional Programming ( scheme is nice and simple and mature ) .
I wish I 'd known about Functional Programming 20 years ago.. . In the world of work , if you understand and can implement basic algorithms in C and C + + you will be miles ahead of 90 \ % of people .
What 's really important for work is good engineering practice .
You should learn about design and testing .
Test Driven Development is a really powerful technique and quite easy to pick up if you are a hands-on learner .
Your code will be so much better as a result .
Again. you 'll be miles ahead of most other people .
Learn about Combinatorial Testing .
See the NIST website .
Do code reviews .
Review code written by people better and more experienced than yourself .
That 's a very powerful way to learn what works and good style .
Befriend some grey-beards and heed their words .
Continuous integration , refactoring , ... it 's a lifetime 's challenge but it 's great fun and very rewarding .
Finally , knowing Bourne shell ( or bash ) scripting is as very useful skill to have .
It opens many doors and can make you a very valuable team member since many people only know GUI tools ( Visual Studio ) .
Do n't over-emphasise the PHP .
It leads to dead-end jobs that are way beneath you .</tokentext>
<sentencetext>I come from a very similar background to yours and am largely self-taught as well.
As far as Computer Science goes, the important things in addition to what you have already studied are Algorithms (Knuth, Sedgewick) and Functional Programming (scheme is nice and simple and mature).
I wish I'd known about Functional Programming 20 years ago...
In the world of work, if you understand and can implement basic algorithms in C and C++ you will be miles ahead of 90\% of people.
What's really important for work is good engineering practice.
You should learn about design and testing.
Test Driven Development is a really powerful technique and quite easy to pick up if you are a hands-on learner.
Your code will be so much better as a result.
Again. you'll be miles ahead of most other people.
Learn about Combinatorial Testing.
See the NIST website.
Do code reviews.
Review code written by people better and more experienced than yourself.
That's a very powerful way to learn what works and good style.
Befriend some grey-beards and heed their words.
Continuous integration, refactoring, ... it's a lifetime's challenge but it's great fun and very rewarding.
Finally, knowing Bourne shell (or bash) scripting is as very useful skill to have.
It opens many doors and can make you a very valuable team member since many people only know GUI tools (Visual Studio).
Don't over-emphasise the PHP.
It leads to dead-end jobs that are way beneath you.</sentencetext>
</comment>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_30</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200134
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31205872
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_9</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203696
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31208976
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_3</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200224
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31209784
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_2</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202262
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_25</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200678
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_4</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203054
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_15</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199298
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199688
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200542
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_33</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200206
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_1</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202884
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_23</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31205762
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_14</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202158
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_13</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199790
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203464
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_38</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200946
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_29</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200110
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_31</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203234
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_8</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199298
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201130
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_19</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31205000
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_10</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31317692
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_12</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199298
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199688
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31206994
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_26</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203210
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_7</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200902
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_27</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201320
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_18</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201584
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203914
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_6</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31204008
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_21</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200134
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202930
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_0</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202176
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_17</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202068
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_20</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199996
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_22</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199868
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201630
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_24</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31221388
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_37</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199864
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31206918
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_5</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200858
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_16</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203570
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_11</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200224
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31208738
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_32</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199796
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_34</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200792
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_36</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200068
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_35</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200372
</commentlist>
</thread>
<thread>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#thread_10_02_19_147251_28</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200160
http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31208634
</commentlist>
</thread>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.8</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200402
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.11</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200194
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.14</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200620
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.5</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199768
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.2</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199704
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203570
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200792
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202262
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202068
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202158
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200068
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31205000
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31205762
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200902
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200946
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203210
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200110
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200678
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200372
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200206
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.17</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200718
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.0</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200448
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.15</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199482
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31317692
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199864
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31206918
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31221388
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201320
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203696
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31208976
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200134
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202930
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31205872
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199796
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200858
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31204008
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199996
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201584
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203914
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200224
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31209784
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31208738
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203054
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203234
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202884
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31202176
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.6</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199572
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.13</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199790
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31203464
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.4</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199298
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199688
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200542
--http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31206994
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201130
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.18</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200300
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.9</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200102
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.12</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199868
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31201630
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.3</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199566
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.10</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199902
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.1</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200160
-http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31208634
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.16</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31200108
</commentlist>
</conversation>
<conversation>
	<id>http://www.semanticweb.org/ontologies/ConversationInstances.owl#conversation10_02_19_147251.7</id>
	<commentlist>http://www.semanticweb.org/ontologies/ConversationInstances.owl#comment10_02_19_147251.31199904
</commentlist>
</conversation>
