sgeisenh

I'm curious, what kind of a solution are you looking for with that problem? The trivial solution of concatenating the lists and then using a library sort (or cobbling together quicksort) is about as good as it gets for small lists.

For large lists, the best you can do is copy the lists into an array, use a parallel n * log n array sort, then fix the pointers.

The problem doesn't seem to require any real thought. It is difficult to make optimizations because the problem isn't especially well defined and the optimal asymptotic performance is obvious the moment the word "sorted" is uttered.

Yeah, random pivot quicksort is n log n expected case. Its pretty easy to show that it is realistically impossible to exceed n log n for large data sets. The constants are quite high, though, due to the need to generate a random number for each element.

Additionally, quicksort is just as easy to implement in parallel as mergesort and runs about as fast since it can be performed in-place.

Computer Science trains students in thought processes. Since quite a few companies use a limited number of tools and frameworks, most CS graduates can jump in and be productive pretty quickly, given the proper on-site training. Problems arise when employers expect graduates to be immediately productive working with unfamiliar tools in an unfamiliar environment.

Several undergraduate programs offer engineering practicum programs in which students are paired with organizations to work on open source software. These opportunities can help to familiarize students with some of the engineering practices in the industry. Every company is a bit different and development practices change often.

I am partial to services that let me use OBS. Not sure why several streaming services are rolling their own desktop clients.

I have a late 2013 15 inch MBP that regularly reaches 100 degrees C when running Adobe Flash. The only other time the machine has exceeded 70 is when I tried running Steam games at 2880x1800.

The hardware simply shouldn't get that hot, no matter how poorly optimized the software might be.

At least you know the adapter is working if it crashes your computer. I am lucky to get the adapter to work properly and when it does, plugging in my Shimian crashes my MBP.

Does anyone else find Clojure's syntax a bit obtuse? I feel like basic recursive definitions are much clearer in Haskell and ML. To sum over a list using an accumulator shouldn't take more than two or three trivial lines of code.

Agreed. Lectures enforce pacing and accountability better than I ever could on my own.

Check out /r/unixporn. There are some excellent setups in there. I think the lack of a standout tiling window manager might be the result of the quantity of excellent WMs in existence. Regardless, if you've never had an experience using a tiling window manager, I would highly recommend it. Once you get past a certain threshold, your productivity skyrockets!

What is excellent about chamber music, in particular, is that no individual makes the musical decisions. Each musician is talented enough to be able to react and expound upon the decisions of each of the other players. Honestly, chamber music is often more of a social challenge than a technical or musical one.

Often times, in the standard repertoire, the conductor doesn't necessarily do anything in the performance. It is in the preparation, when the conductor disseminates their interpretation to the ensemble, where their artistic vision is forged.

This is an interesting idea, but I suspect that most consumers are inclined to pick and choose services. Maybe Amazon can fill a niche with this type of offering.

Beyond viability, I find the implications of this post terrifying. The line between licensing and ownership is becoming blurred. And the prospect of having so few personal assets is disconserting.

The arguments of most of these types of posts can be hand-waved with "use the right tool for the job."

But honestly, plumbing and electrical infrastructure is a terrible metaphor for a development framework. There is no situation in which a handyman would be praised for advocating complex systems. They complicate every single layer of the build.

A sizable chunk of the "hype" tech facilitates faster, more efficient development at fairly low cost (maybe sacrificing some scalability or stability).

It would be reticent of me not to mention how much the deluge of JavaScript frameworks pisses me off. It is overwhelming trying to keep up.

Inconsistent sleep patterns can also cause circadian rhythm disorders. I struggle with delayed sleep phase syndrome as a result of years of poor sleep hygiene. I use what is called chronotherapy (http://en.wikipedia.org/wiki/Chronotherapy_(sleep_phase)) every few months or so in order to put my sleep schedule back at a reasonable time.

I think, within a certain threshold, it is definitely more financially responsible to bootstrap. Though, I agree with your point about Twitter, etc: if you're a seasoned developer/entrepreneur with a large scale idea that requires serious capital to get off the ground, you can't bootstrap. But for something that is effective at a small scale and can be built from the ground up, the timeline only shifts a small amount (so long as you pursue all marketing avenues available).

I'm assuming that your friend evaluated the risks of fundraising and made a reasoned choice. I don't think it is fair to reason about his venture in hindsight.

I am talking about frontier A* where you discard all nodes that have already been visited. This requires the heuristic to be consistent. As opposed to the breadth-first heuristic search which revisits nodes.

If we operate under the assumption that each intermediate path found is shortest for its respective endpoint (which is the fundamental insight for Dijkstra's), we could potentially throw away the solution because it travels through the "visited set."

Edit: The paper you cited uses a traversal slightly different from traditional A*.

I'll do my best to provide an example. It is hard to come up with a general idea, but I can demonstrate using a graph: http://i.imgur.com/AwpTeRt.png

The numbers in the nodes represent heuristic values at each node and the numbers on edges represent edge weights; we're looking to get from S to T.

Our heuristic is admissible because it never overestimates the distance to the target.

Consistency dictates that the heuristic value at any node may at most be the weight of any out-edge added to the heuristic value of the node that the edge connects to. So in our example, the heuristic at A is 3, but at B it is 0, but 3 > 1 + 0, so our heuristic is inconsistent.

The reason this causes issues is because our algorithm assumes that any visited path is the shortest path to the end vertex of that path. So when we traverse this graph, we will visit B first, because the sum of its heuristic value and the respective edge weight is less than that of A.

The discussion of heuristics includes only information about admissibility and not consistency. An admissible but inconsistent heuristic can also cause A* to miss the correct solution.

While breadth-first search and Dijkstra's have a lot in common, Dijkstra's is a priority first search which is inherently sequential, whereas there is some parallelism to be had in BFS since you can check the neighbors of your frontier concurrently given a data structure with which it is efficient to do so.

Wait, do the results from each round make a difference in subsequent rounds? I didn't take the time to implement a solution to problem C because I felt like it would take too long.

Authenticator tokens are pretty robust systems. I'd like to see more services start to make use of them.

With the exception of hybrid shipping, I am consistently impressed by Amazon's ability to ship using the most appropriate service.

Perhaps it is due to my location in an urban area; when I use Amazon 2-day, it arrives in either 1 or 2 days unless shipped using SmartPost in which case it arrives in 5-7 days.