jefffoster

Interesting! The single page view is at http://www.pcmag.com/print_article2/0,1217,a=278114,00.asp?h...

An excellent web site! I first came across it when the topic of my PhD thesis was noted as a half-baked idea! (http://www.halfbakery.com/idea/gait_20recognition).

I got annoyed by some of the daft names in Java, so I went through and found some of the worst offending method names. The longest method names I could find are "supportsDataDefinitionAndDataManipulationTransactions" (for Java Development Kit) and "setApplyWebRequestInterceptorsToRenderPhaseOnly (for Spring).

(see http://www.fatvat.co.uk/2011/05/method-names-in-java-develop...) for more details.

I hadn't heard of the Carrington event (http://en.wikipedia.org/wiki/Solar_storm_of_1859). Even in 1859 it caused havoc, so it's interesting to think what it would do to modern infrastructure. From the article:

Telegraph systems all over Europe and North America failed in some cases even shocking telegraph operators. Telegraph pylons threw sparks and telegraph paper spontaneously caught fire. Some telegraph systems appeared to continue to send and receive messages despite having been disconnected from their power supplies.

Do you mean seam carving? (http://en.wikipedia.org/wiki/Seam_carving)

The team I worked with tried something similar where we broke down tasks into cards, where each card represented something that should take about a day to complete. Knowing how bad I am at estimating how long tasks take, I was sceptical whether this would work, but it did! After a few months, the team settled down into doing 30 or so (+/- 10% or so) cards per week. This proved very useful for bargaining for more time for feature development and generally being more predictable.

The takeaway for me is that good estimation is possible, and that by tracking those numbers you can improve your own estimation skills.

Some other reading material that I found useful in this area was Evidence Based Scheduling (http://www.joelonsoftware.com/items/2007/10/26.html) and Software Estimation (http://www.stevemcconnell.com/est.htm)

I just use it for my boxes. It doesn't stop me putting something silly in a make file (as in the example here), but it does stop me getting burnt by it.

I use the safe-rm (http://freshmeat.net/projects/safe-rm) package to help me avoid doing this kind of thing.

The code is available at https://github.com/path64

Sounds interesting. The article from Martin Fowler (http://martinfowler.com/articles/languageWorkbench.html) talks about language workbench's like this in 2005 and this seems to be the first available mainstream implementation of one.

Intentional Software (http://www.intentsoft.com/) also promise a package like this, but haven't delivered anything publically as far as I'm aware. There's also JetBrains MPS, but not much seems to be said about that any more.

All of this seems to be a kludge though. Java's weak at allowing new syntax (no operator overloading, no higher-order functions, no dynamic dispatch) so you need verbose code to implement your own language. With a language more targeted at this, such as Lisp, would you need all this?

A very simple change would be to only display comment scores once you have voted on a comment yourself. I'd hope this would encourage more voting and dissuade group-think.

Here's a few of my favourites.

agrep - approximate grep based on edit distance).

GNU Global - source tagging system that integrates with the shell (less -tfunc displays the function given in the shell).

xmllint - xml validator, pretty printer and schema validator.

xmllint is another hugely useful xml tool.

There's an interesting write up about the idea of "everything is a function" in Haskell at http://conal.net/blog/posts/everything-is-a-function-in-hask....

What's your rationale vbehind everything being a function?

Will Thimbleby (http://will.thimbleby.net/misc-an-experimental-language/) also explored similar ideas.

See also the SIMILE Widgets (http://simile-widgets.org/) project which is spun out from research at MIT. I've been using the Timeline control and found it very easy to use.

For another example, Redis uses much less memory per key when compiled for 32-bits.

It's still a great text editor, you don't have to install all the other bits and pieces.

Previous discussion here (http://news.ycombinator.com/item?id=1545178)

You could apply the same techniques to comments. Voting up comments I enjoy reading would promote comments I like (and hopefully drown out the ones I don't). Whether this would look at the contents of the comments or just increase the weight of the commentator is up for discussion.

That's true and I guess that's the biggest challenge of implementing such an idea. Given that I like X,Y,Z would I also be interested A,B and C?

Over time the readership and topics covered of HN has grown and maybe the quality has gone down. Perhaps one way of solving this problem is to find a way to present a smaller subset of data to different groups so that they can focus on the areas they like?

My favourite kind of posts are big data, web app architecture and functional programming. If my view of HN was skewed by my interests, then my perception of the quality of HN would improve. Chances are that other people would fit into my interest groups and hopefully that would promote tighter, smaller groups and perhaps the quality would increase.

Stackoverflow's tag system seems to work well, but assigning tags would introduce extra burden on people (and another area for disagreement). I like the idea of a machine learning approach where I see articles based on the content on previous articles I enjoyed (via voting). The same could work for comments. Going further, perhaps this could even suggest people with similar interests to yours.

+1 for Mozart/Oz. It's a great language for exploring the various paradigms of programming. Working through "Concepts, Techniques and and Models of Computer Programming" (http://www.info.ucl.ac.be/~pvr/book.html) with Mozart/Oz gives a great tour of programming techniques and manages to stay in one language for the whole journey.

There are some attempts to formalize OOP. See Cardelli's "A Theory of Objects" (http://lucacardelli.name/TheoryOfObjects.html) for one example.

Just because I'm sure at least one other person won't know the acronym, but I think SHDH is Supper Happy Dev House.

There was also an older project known as Spec# at http://research.microsoft.com/en-us/projects/specsharp/

My first stab at being an entrepreneur was buying normal 3.5" disks, stamping holes in them and selling them as pristine 3.5" HD disks. Let's just say it was less successful than I'd hoped.

> I am confident that later versions of JDK would catch up

With the current situation with Oracle, Apache and Google I'm not entirely confident that the Java language will evolve in any significant way.

Acovea (http://www.coyotegulch.com/products/acovea/) is a genetic algorithm for analysing the performance of code with various optimization flags.

There's a practical example of this being used on a Haskell program at http://donsbot.wordpress.com/2010/03/01/evolving-faster-hask...

Years ago, I worked on a project that involve capturing images filmed with an ophthalmoscope and mosaicing them into a complete image of the back of the eye. Part of that involved finding out how bright a light we could get away with beaming into peoples eyeballs. I don't remember specifics, other than being surprised at how much you could get away with.

A quick search showed that there are standards that cover this and include infrared light (see http://www.fda.gov/MedicalDevices/DeviceRegulationandGuidanc... for more information).