jefffoster

See https://news.ycombinator.com/item?id=8096185 for previous discussion

Reminds me a little of JWZ's "on toolkits" (https://www.jwz.org/xscreensaver/toolkits.html).

Writing lock screens is hard!

I played with this idea too, and ended up with http://www.methodnamer.com/

Chess has a 50 move stalemate condition (http://en.wikipedia.org/wiki/Fifty-move_rule) that prevents this happening.

Whilst I agree that technical leadership is one aspect that skilled engineers can develop (and I agree that it's important for all engineers) there are many more.

For example, developers can grow into great product managers. Some can deep-dive into a topic and develop by sharing that knowledge through conferences, blogs etc. Some are interested in the people management side of things (scrum, kanban etc). All of these (and much more) are incredibly valuable and increase the value to the company they work for.

The challenge for companies is to recognize all these degrees of value (and reward them appropriately). I did some work to try and capture this with a visualization called a skills map (http://blog.red-gate.com/skills-maps/). Any feedback greatly appreciated!

There's 10 years of experience, and there's 10 years of having the same experience time and time again.

With the naive representation of a string as a list of characters [Char], it is. The only way to get to the end of the list is to recursively take the tail of the string (see the source at http://hackage.haskell.org/package/base-4.6.0.1/docs/src/GHC...).

There's alternative representations with different trade offs, such as Data.Text

You can type 'Bambi' on the front page for an even more retro version.

Jack Reeves essays on software design are also worth a read http://www.developerdotstar.com/mag/articles/reeves_design_m...

Languages are simple syntactically, but I'd have a hard time believing that anyone could pick up the set of idioms necessary to effectively use a new language in a few days.

Norvig it covers this well in his Teach Yourself Programming in Ten Years (http://norvig.com/21-days.html) essay.

The msdn article [1] is a great reference on the strangeness of the Windows path naming conventions.

[1] http://msdn.microsoft.com/en-us/library/windows/desktop/aa36...

This is my understanding of what dependent types [1] will allow you to accomplish (at least in some imaginary future).

[1] https://en.wikipedia.org/wiki/Dependent_type

Something like the proposal for C++ Concepts captures some of the semantics via axioms (http://en.wikipedia.org/wiki/Concepts_(C%2B%2B)#Axioms) seems like a really interesting solution for this idea.

I've always thought inheritance is used to model is-a relationships. Sharing code may be a side effect, but it's certainly not the reason to use it.

Using inheritance to share code is usually better achieved by factoring that code out to a separate object and having the objects in a inheritance relationship use it by composition.

This is "a variant of Win32/Injector.Autoit.HG" trojan according to the ESET antivirus on my machine.

Isn't this what omniscient debugging is? http://www.lambdacs.com/debugger/

Great quote from that page, "The ODB is as close to a silver bullet as you can get. Why don't people use it?"

I tried it out and the CircleCI team installed the latest Haskell platform, so I was up and running with cabal tests in five minutes.

I saw a good analogy of the tax system to computer code. The inland revenue express their intent of the tax system in code (or at least legalese). It's the job of accountants to exploit bugs in the tax system.

To misuse a famous quote:

"There are two ways of constructing a tax system. One way is to make it so simple that there are obviously no deficiencies. And the other way is to make it so complicated that there are no obvious deficiencies."

In Java, the compiler won't tell you that a variable may be null. In Haskell (at least when you compile with -Wall, strange this particular warning isn't the default) you'll get an error if you've failed to handle all the variations of data that you've provided.

There's a good presentation my Yaron Minsky about OCaml in the real world where he cites this as a major advantage (in OCaml, failing to match all patterns is an error by default).

I found a similar file to this (a zip file that contains itself) and e-mailed it to a friend at work. He never received it, but I thought nothing of it (I assumed the email filters just destroyed it).

A days later the mail server stops working and the sysadmin turns up at my desk. Turns out the anti-virus scanner had been unzipping and scanning repeatedly. It eventually filled up the entire disk and bad things happened.

I think that quote is appropriate if you fear collisions with your own data set. The worry with a cache scheme like this is people would be actively seeking to find cache collisions.

Actually, for a poker hand evaluator the last thing you want to do is sort the hands. There's a small enough number of unique card combinations that you can arrange it so that you look up in pre-computed tables more often than not.

One clever trick is assigning a prime to each card value. By multiplying the values together you get a unique number representing each hand without needing to sort.

There's a great description of an algorithm at http://www.suffecool.net/poker/evaluator.html.

There's a great write-up of why doing cryptography in JavaScript isn't a good idea at http://www.matasano.com/articles/javascript-cryptography/. The browser is a very difficult environment to run your code in a trusted way.

There's also Amazon Direct Connection (http://aws.amazon.com/directconnect/) if you happen to be on the same backbone / data center.

There's no mention of the computing at school (http://computingatschool.org.uk/) group - is there any link up between the two?

There's an interesting area of research called Homomorphic encryption (http://en.wikipedia.org/wiki/Homomorphic_encryption). In this schema, certain properties of the data are maintained even after encryption. In the general case you would be able to stored encrypted data in the cloud and perform operations on it without needing to decrypt the data.

I did something similar at http://methodnamer.com/ and also some useless graphs and rants about the long names in Java (http://www.fatvat.co.uk/2011/05/method-names-in-java-develop...)

There's also Intentional software (http://intentionalsoftware.com/) who offer a similar product. It was hyped quite heavily a few years ago, but I've not heard much about Intentional Software's product or MPS.

Is anyone seriously using a language workbench tool? If so, what are you experiences with it?

There's a handful of Haskell videos on ontwik at http://ontwik.com/category/haskell/.

There seems to be quite an overlap with the Galois talks though (but thanks for pointing that resource out as I hadn't seen it).

Has any work been done to solve reusing passwords with homomophic encryption? (this is a scheme that allows you to perform operations on the encrypted text without decrypting it).