SoylentNews is people
SoylentNews
The New York Times has coverage on the phenomenon of Developer Bootcamps, that claim to do in a matter of a couple of months what used to take at least a couple of years for an associate's degree. These cram courses are apparently getting about a 75% job placement rate.
Have any Soylentils either gone through these programs, or worked with others who have? If so, what are your experiences?
This discussion has been archived.
No new comments can be posted.
Developer Bootcamps - Be a Programmer in Two Months!
|
Log In/Create an Account
| Top
| 46 comments
| Search Discussion
The Fine Print: The following comments are owned by whoever posted them. We are not responsible for them in any way.
No self-made man ever did such a good job that some woman didn't
want to make some alterations.
-- Kim Hubbard
(Score: 2) by maxwell demon on Wednesday October 15 2014, @06:05PM
You don't teach sorting so that people know how to sort (or at least you shouldn't). You teach sorting so people
Similarly you don't teach linked list so people learn to implement linked lists. You teach linked list so people learn about handling pointers, and about how data structures affect the efficiency of different operations.
Design patterns are no replacement for this. Or at least I know of no design patterns which use pointers or recursion. No, there's nothing wrong with teaching design patterns. It's just wrong to think that's sufficient.
The Tao of math: The numbers you can count are not the real numbers.
(Score: 1) by linuxrocks123 on Wednesday October 15 2014, @07:03PM
I totally and completely agree with you in general, but I would replace the reason for sorting as general algorithms rather than recursion in specific. The only recursive sort I know off the top of my head is mergesort.
(Score: 2) by No.Limit on Wednesday October 15 2014, @07:28PM
heapsort (for the heap structure)
quicksort
radix sort
but then you probably wouldn't use recursion for bubble sort, insertion sort, selection sort (ofc you're always free to do loops with recursion, but unless you're coding in a functional language that'd be quite forced).
Though I think sorting isn't really taught for recursion, but rather for complexity theory and also because it's one of the most important problems to solve. Being able to decide which sorting algorithm is good for which situation can be very useful in many situations.
I believe some C/++ libraries use quick sort for their sorting which is worst case O(n^2), which is way worse than e.g. merge sorts worst case O(n*log(n)). But quick sort is still really good because it's in-situ and average O(n*log(n))
Recursion can be taught very well with tree structures (binary trees, balanced trees, abstract syntax trees etc) or simply with functional languages.
(Score: 1) by ld a, b on Wednesday October 15 2014, @09:58PM
Complexity theory is undermined by sorting algorithms.
In the beginning, we had a O(n) algorithm, then we found out a way of sorting in O(n log n) time, finally, we all settled for an O(n^2) algorithm because it is wipes the floor with everything else on average.
Sounds convincing.
10 little-endian boys went out to dine, a big-endian carp ate one, and then there were -246.
(Score: 2) by maxwell demon on Thursday October 16 2014, @07:00AM
The current state of the art is Introsort. Almost the same speed as Quicksort, but complexity O(n log n).
Anyway, Quicksort teaches an important lesson about complexity theory as well: Worst case complexity is not the only consideration you should take into account.
Oh, and what is the O(n) algorithm you are speaking about?
The Tao of math: The numbers you can count are not the real numbers.
(Score: 1) by ld a, b on Thursday October 16 2014, @11:34AM
Sorry to disappoint you if you were hoping for something else, but the answer is radix sort which was developed to sort US census data back when tabulating machines were the bleeding edge.
10 little-endian boys went out to dine, a big-endian carp ate one, and then there were -246.
(Score: 2) by No.Limit on Thursday October 16 2014, @07:13PM
Radix's sort O(n) runtime is quite controversial as it's actually O(n*log(k)) where you can have at most k different elements that must all have a binary representation.
More on this here [stackoverflow.com]
For comparison only sorting algorithms (much smaller constraint) O(n*log(n)) is proven to be the best worst case running time.
(Score: 2) by RaffArundel on Wednesday October 15 2014, @09:18PM
You don't teach sorting so that people know how to sort (or at least you shouldn't). You teach sorting so people...
Correct, and you apparently misunderstand my point. I am saying that sorting is an excellent programming teaching opportunity, because it is inherently unintuitive to write an efficient sort. In fact, you have them try it, so you can walk them through the concept of an algorithm and breaking down the problem into units. I've done it and it is very successful to get some basic points across. However, now they would just look up their assignment on-line and I'd get the same half-assed quicksort which would be obviously cribbed from the web. I was bemoaning the state of students nowadays!
Design patterns are no replacement for this.
Replacement for what? I didn't say that, did I? I said patterns (not Design Patterns, patterns in general) are replacements for experience, basically allowing them not to make those rookie mistakes everyone tends to do when starting out. Patterns like limiting scope of variables, creating methods from duplicate lines of code, etc. Those kinds of patterns. Recursion is a pattern: repeatable technique that's repeatable, pun intended. I mentioned Design Patterns so the students know there are some "best practices" out there. I did do some pretty heavy MVC discussion for the other class but that was web programming. For the beginners it was only a taste.
I can see me trying to edit my post down for length may have impacted the clarity!