I spoke to one of my colleague who recently been rejected by an ecommerce giant due to lack of data structures and algorithms knowledge. He is pretty good developer with solid understanding of Java and related technologies. His side of the story was that, he forgot majority of the data structures and algorithms part where we need to implement these. Instead, his several years of experience is mainly focused on using the API provided by Java.
Especially for people who either came from non-computer science background or learned programming by themselves, this is definitely a problem
What do you think of a developer's having knowledgeable on data structures and algorithms and to what extent?
Sai Surya, SCJP 5.0, SCWCD 5.0, IBM 833 834
http://sai-surya-talk.blogspot.com, I believe in Murphy's law.
Sai Surya wrote:What do you think of a developer's having knowledgeable on data structures and algorithms and to what extent?
Good question. Hmm where should I start? Back in the days, I always thought having a good understanding of data structures and algorithms was key to becoming a good programmer. OK pick up a good book and learn the fundamentals (eg List, Set, Map, etc) along with sorting and searching (fun fun).
Once the basics are covered, the more advanced stuff can be like "where are we gonna use it?". At the end I believe the knowledge in this area should be need is:
* definition of common data structures & algorithms
* recognize what situations to use what
* appreciate the fact that there may be other/better approaches to any data structures and algorithms
* able to implement basic functions of such
Also having such a book as a reference is good. Just my 2cents
How does he know that it was lack of data structures knowledge that meant he did not land the potential job? Jobs are supposed to go to the best‑qualified candidate, so the fact he didn't get the job means there was somebody else the company thought better for the job. The interviewer sometimes tells the unsuccessful people what their problems were, and that may only have been one of the problems.
On the other hand, I would expect an experienced person to have a knowledge of data structures; somebody who has been programming for a few years ought to know how to write a doubly‑linked list or know why you use merge sort for Object arrays in preference to quicksort.
In my opinion, building up a repository of data structure and algorithm knowledge helps developers think better, and come up with elegant engineering solutions
to software problems we face in our projects.
As a quick example, take this blog post I came across yesterday by a Khan academy developer on typo handling in search queries. It's a simple and common enough requirement.
Now imagine a dev who is not interested in expanding their repertoire of DSAs, who does not follow the works or blogs of brilliant computer scientists like
Peter Norvig, who does not appreciate the inherent beauty of algorithms. Such a dev would probably implement a clunky solution using something they are already
familiar with, such as a database LIKE query.
But take the time to work through that blog post and all its linked articles, try to implement them all yourself, and you'll find how simple and beautiful the various solutions are.
Don't miss reading the link on succinct tries, which is another example of solving a different problem elegantly.
I have to confess until quite recently, I was such an ignorant dev myself. I don't have a computer science background and am mostly self taught, save for a few elective subjects. But a decade plus of working successfully as a software professional, rarely using any special data structure other than hash tables, gave rise to a kind of hubris that knowledge of DSAs is a waste of time.
But I discovered that I was a frog that had simply adapted nicely to its own well. The moment I jumped into other wells - such as data science, text mining and machine learning - I started sinking pretty quickly.
Experience is meaningless if the solutions and thinking behind them are not elegant. Knowledge of DSAs is an important differentiator between a "software tailor" and a "software engineer".
A software tailor is somebody who is good - maybe even excellent - at stitching together APIs written by others, but finds themselves in trouble when there are no APIs for their problem [I don't remember now where I saw this term "software tailor", but I agree with the description]. No matter what their experience, they remain software tailors.
A "software engineer" on the other hand has no such hiccups when faced with fundamental problems. I sort of agree with this programmer competency matrix, especially on the computer science related rows.
An added benefit I have found by exploring DSAs is that I can implement projects in algorithm intensive fields like data science, NLP and ML, which are a hell of a lot more interesting and fun than the typical spring hibernate CRUD webapp.
Surfs up space ponies, I'm making gravy without this lumpy, tiny ad: