skysight-inc/HackerNews huggingface dataset:
You will probably get mixed opinions. I prefer that a "sign-up" page gives clear indications of the minimum standards required for passwords (although these should be inclusive and not exclude characters).

Validating the user name is always a bit of a problem - assuming you want unique usernames (and can't use an email address). It is nice to be able to offer some user feedback (with some back end validation via AJAX) but then again you don't want to give too much away about pre-existing user names.

On a "sign-in" page then there should not be any validation of the password at the client end - this should only be done at the server and if the user name/password combination fails then the user should be told of the failure but not which element failed validation. I also like to slow the response to an invalid log-in.
Java developer says he built, launched basic open source office suite in 30 days
> When developers don't have a feel for this, it really slows them down -- both figuratively and literally.

Of course, I'm just not clear how Big-O helps with that. To me, the required insights seem to be:

* Things are slower when the computer has to do more work

* A feel for what strategies result in the computer doing more work

I can't think of many cases when saying "This algorithm is O(N^2)" is significantly more useful than saying "This algorithm is going to be really slow".
Good point. But its not strictly 'internet' is it?
The good thing is that the regex will be the same. It's also pretty trivial to write a polyfill to work on old browsers. I've found it's really nice to define that in one place then to use it everywhere. Newer users get the HTML5 validation, older ones the Javascript fallback, and everyone gets a second round of checking before it hits the database.
The nice thing about open-source: Canonical's self-interested advancements of Ubuntu have made the OS quite a bit better.

By "the OS", I am referring, of course, to Debian. :)

I think (perhaps-douchebaggy) self-interest is perfectly fine when it has positive externalities in the world. You're free to avoid the drama of the Ubuntu project itself, while continuing to reap the rewards on the rest of the ecosystem from its existence.
Hummm I thought capital gains were taxed lower

And yes, I could take the money, wait a couple of years (after all it's MS, you can usually go for something that interests you better)
Rust seems more like a tool, a means to an end, rather than a product.
REALLY?

This is about the best news I've heard all week. Thank you VERY much for pointing us to this.

The costs of Basic Income test programs in the third world are SO damn low that I've been thinking for a while that it's possible to run some fairly credible privately-funded trials. Really pleased to find someone else doing it so I don't have to try to learn the NGO side of things :)
Well, immutable classes are final. Thus, suggesting to make it abstract does suggest the opposite, IMHO.
Very useful list. Will try it and report, Thanks
You don't have to be a perl user but this has never been a goal of perl.

http://bigthink.com/videos/why-perl-is-like-a-human-language

Love it, hate it, it just isn't what perl is about.
I believe JITting (code generation) happens at a later stage, after the source code had been parsed (or perhaps even "tokenized"/"lex'ed" is more appropriate?)

So even an "unreliable" syntax wouldn't matter much since the jitter kicks in after the parser had delivered its results.
So, what exactly is Wayland?
Well, I would say we get paid a decade worth of minimum income levels pre-tax and pre-expenses, but after taxes and high cost of living in the areas we generally live in, and after repaying loans to obtain qualifications to work these jobs, I'd say there's only one or two years of minimum income left over.
As I quite what I written earlier (https://news.ycombinator.com/item?id=5770682),

"Those people are not the norm, they are the special case. Well yeah, you’ll not know you’re a special case unless you took a chance. And that’s the hard thing about it."
Wayland is intended as a simpler replacement for X, easier to develop and maintain. - http://wayland.freedesktop.org/

Currently it's

Display <- Compositor <- X11 Client <- X11 Server <- App

Wayland:

Display <- Compositor (Wayland) <- App
HTML5 is a fixed standard - I assume you mean something else by that. the lines between OS/VM/browser are blurring more and more. I find what Rich Hickey is saying really interesting. to me the next great step is dynamic computing. so the stuff that Bret Victor is doing is going to be huge IMO. defining dynamic behavior and services is the future, not so much widgets and mouse actions.
I want to be an hacker, please tell me how
From time to time I take some time and reflect on the past year(s) and I try to visualize where I want to be in the future.

In the future, I want to be an hacker. That being said (perhaps in an offensive way for some of you here) I don't want to spend hours on a black background with yellow letters trying to worship some nerd guys impressive trick.

What I want to do instead is to master a language, where I would then be able to do such things.

I have some notions of html, css and javascript, but they are almost not even worth mentioning.

I would like to have your help with pointing me in the direction of a programming language that I should learn.

I would like to be able to hack softwares, create my own softwares, keyloggers, trojans, etc...

It'd be great to hear what you think!
>So in my opinion while anonymouz is technically correct, it does not make any sense to see it that way.

I absolutely agree, and anonymouz's approach is not how I would approach time complexity. I thought it was an interesting point and so I decided to explain where he was coming from, but practically I don't think it makes any sense.
How pointless, the EU couldn't impose this even if they wanted to. It'd be up to national governments.
The Google mantra "Don't be evil" - not! Decision to drop XMPP is bad/evil. Seems more like the strategy of customer lock in.
That was aimed at students. Once Lisp gets applied to a domain, we get ready-made libraries, syntax-extensions, etc. If you program Emacs, you don't start with a blank copy of Emacs Lisp, but a huge library and a huge amount of built-in stuff. That's all documented and there are common ways how to use and program in Emacs Lisp.

Sometimes developers stay near Lisp (like in Emacs and Emacs Lisp), sometimes the end result uses Lisp, but in a different language on top.

What you learn from Lisp, is for example that macros can extend the language and that there are common idioms how a macro should look&feel. But instead of a completely new language (Perl, Python, Lua, Ruby, Basic, Bash, Rebol, Abap, Groovy, Javascript, ...), with a new syntax ('C-Like', 'Java-Like', 'Pascal-like', ...), a new runtime, a new interpreter, new libraries - instead of that we get a Lisp with some extensions (macros, functions, data structures, s-expressions, ...).
Surte, but one cannot underline enough the importance of relevant and correct examples. May I suggest something like "<a href='verybiglogoftheday/' download='log-2013-12-11.txt'>"
I don't think this result means anything much for compiler optimization in Perl. Perl is definitely a difficult language to parse, a difficult language to interpret, and its flexibility makes for very tricky compilation (have there been any usable compilers for it?)

BUT - you can't really draw the link between a language that is turing-complete to parse, and one that is difficult to parse. An example of this would be to take the most simple, basic language you can think of, and add a backtick-like operation. As in, you can put `echo hello` into the source and the string will get replaced by the output of the enclosed command. The source language instantly becomes turing complete (you're having to execute code, after all), but your one-off parser hasn't become much more difficult (you just call exec() and wait for the output)
It's worth considering this dystopia in parallel with this the oft-quoted saying that "In the future, there will be two kinds of people: those who tell computers what to do, and those who are told what to do by computers".

Then throw in this: http://www.economist.com/news/business/21578360-brain-work-m...

Perhaps the first group will dwindle faster than we think.
That's one way to look at it. From the perspective of a researcher, if you're true to your work, you're really at the vanguard asking hard questions and probing the limits of your own mind and its fallacious thinking .. no matter how small your domain of interest is.

I came across a joke once that resonated since it felt like truth being spoken in the clothes of humour -- "When you finish a bachelor's degree, you think you know something about something. When you finish your Masters, you realize you don't know anything about anything and are in awe of other minds around you. When you finish your PhD, you realize that nobody really knows anything about anything, including you."

The offshoot of that last realization is true humility that shows as a deep appreciation for the steady progress being made at the boundary of knowledge, and the wisdom in finding the right question to ask.

To put it another way, both endeavours have tremendous impact on the person. If "finding out about stuff" is your thing, getting a PhD would be worth it. If "doing stuff" is your thing, a startup would be worth it.

PS: This one just submitted his thesis and is considering starting a company.
Wouldn't inserting a single record in the index be O(log n) (if n is the number of records in the index), and creating the entire index be O(n log n)?
I'd think it's always a good idea, no one minds when there are easy to run unit tests included in the open source project that they just downloaded. However, depending on time restraints, timing, financial concerns, scale, dealing with critical systems, etc, it may or may not be better to push something out without having any formal tests. I think some form of formal testing should be pursued in general.
this was immediately distracting to me and annoyed me very fast. Maybe it's because I'm reading on a mobile device and "x mins remaining" took up ~1/4 of my screen every time I scrolled. What value exactly does it add? It's likely to be wrong, and just got in my way.
Things I Wish I Were Told About Angular.js
A more social Adobe Creative Cloud
Adobe has been rolling out some major changes and updates to Creative Cloud. While the new subscription-only model and individual product updates have gotten most of the attention, the new social and networking aspects built directly into CC have the potential to be hugely important to the creative community.
> anonymouz's interpretation is bizarre and definitely not how I'd think about the function.

It is usually understood that one measures the time complexity of an algorithm in the size of the input (only if the input is an integer, would it even make sense to measure it in the value of the input). So you may of course use whatever definition you like, but be careful that statements about the time complexity of certain things are often made without referring to the exact definitions used, and you may then misunderstand them.

For example, when people say "We don't know a polynomial-time algorithm to factor integers" they mean polynomial time in the size of the input (i.e., number of digits/bits of the integer). The problem would trivially be polynomial time if you allowed it to be polynomial in the integer itself.
Those of you who are opposed to Basic Income Guarantees or cash transfers on the basis that you believe they don't work:

Can you define the assumptions / beliefs that make you think they don't work, in a testable fashion? (Ideally in a fashion which would be testable on as small and cheap a scale as possible.)

I'm not asking this because I'm planning to rubbish those assumptions or beliefs. I'm asking because this is an area of enough interest to me that I may look into organising fundraising for trials in the future, and it'd be useful to know what the most compelling hyphotheses to test would be.
Previous HN discussion from 3 years ago - https://news.ycombinator.com/item?id=761103

Also came up in a comment a couple of weeks ago - https://news.ycombinator.com/item?id=5718637
It's like grammar: You don't sit around articulating "this is the subject, this is the object, and I need the third person singular over there" when you write - but knowing the mechanics of grammar allows you to write texts with correct grammar more or less intuitively, and it's easy to reach back and pull out a rule when you think something sounds weird.
Textbooks are not mutually exclusive with learning from experts.
> Both take at least five years.

Europeans do it in 3 or 4.

> In a PhD you have a scholarship and a tutor that tells you what to do.

Salary is usually contingent on applications, work, etc.

After the first half, the PhD should be directing the project, not the tutor.

> A PhD is safer. If you don’t do so well, you are going to get the title anyways.

A PhD is only a PhD if you make it to the endgame. You can fail quickly or slowly in an infinite cornucopia of ways.

> In a PhD you learn a lot about an specific subject.

If you have two brain cells to rub together, you learn just as much about yourself, people's motivations, etc. as you do about the domain.

> If what you want to do is to change the world, go with the PhD.

A PhD is at best learning to do research, not much else, and at worst, a poorly paid programmer or lab tech. Changing the world is thing altogether.
In my opinion the misunderstanding arises due to the lack of understanding of what log n means, and not so much O notation.

Intuitively, logarithms are much easier to understand in the context of exponentials. For example, if there is "something" (be it a function, space, money, etc.) which starts at value "c" and doubles with each iteration: c, 2c, 4c, 8c,..., that is what we call exponential growth and iteration n would be represented by the following notation: c * 2^n.

Where does the logarithm come in? It is defined in the following way:

if a^b = c, then log_a c = b (note: read as log of c in base a equals to b)

so an exponential relationship can always be written in terms of logarithms.

Now, if the answer that we are looking for is not the actual value, but how many iterations did it take to get there ("b" above), that is the direct result of applying the logarithm to the function.

How does it all apply to functions execution time and Big O notation?
Well, if we have a space N that we are searching over via a function F, and this function does so iteratively by dividing search space N into 2 at each iteration and discarding the wrong half, we will have the following sequence representing the space to search over at each iteration: N, N/2, N/4, ..., N * (1/2)^n.

If the question is, how long will it take this function to run? The answer is that starting at space N, the function will run until it has narrowed down the space to 1, so the search is over and it found (or not) what it was looking for. So the question is really, how many iterations will the function need to do? And as explained before this is exactly the definition of logarithm.

Therefore: ('~' defined as 'proportional to')

time to run ~ space to search ~ # of iterations ~ log_2 (N*(1/2)^n) = constant + log (n)

In general, intuitively (not always true though) if there is a function that at each iteration is dividing the size of the work to be done by a constant factor (2,3,4,...) the run time, that is the number of iterations, will be O(log n).
If you're talking about real hacking, try learning to code more than HTML, CSS and JavaScript. You might want to check out Java, Python or Ruby. Maybe take a look into C. Study data structures, and algorithms.

But if you want the "bad" hacking, it's called cracking. I think learning those too and some network understanding maybe essential. But that's just how far I can say. I don't know much about cracking in general.
Got some kind of links to "what Rich Hickey is saying" (who?) and "Bret Victor is doing" (who?) for us mere mortals? ;)
But how can you know how slow it is going to be under a production workload? Is very useful to be able to time some code on a small input set, then extrapolate based on knowledge of time complexity to find out roughly how long the full input will take. If you don't know the time complexity, this is impossible.
Thanks for the suggestion, i'll try fix this :)
European startups: Some practical tips for raising capital in the US
I doubt anyone would mind if you seeded it.
Neither is being a snarky dickhead.

Maybe you should refrain from commenting until you have something "valuable" to offer, too.
It took forever for the coin to drop for me on log n, and it seems it hasn't dropped for the accepted SO answer either.

log n is the height of a tree when the log base and the branching factor of the tree is the same.

Hash lookups are log n, because the hash table implementation is typically a tree.
start by learning grammar..
After similar symptoms and work ethic... I've been on sabatical for the last 5 months after almost passing out in a meeting, then half an hour thinking my heart was going to explode.

The doctor was actually pretty good and got it out of me that the job I was on more stressful than most, basically because of the "tech lead" walking ego fuckwit who would argue that the sky wasn't blue. 17 years in the contracting business eventually got to me - and it was a 'fuckwit' personality type I'd dealt with easily many times prior.

With hindsight, I actually got a little too emotionally involved with, for once, not accepting my time being wasted on another failed project due to idiots running the show...

It was government work, so that might explain it. Take care of yourself, I thought I was dead at 40.

Life is considerably more enjoyable now. Take better care of yourself, eat better, drink less alcohol(?) and avoid fuckwits at all costs :) You're a long time dead - take time to really smell the roses...
It doesn't have to be retrospective. A knowledge of computational complexity can be used to make predictions about the performance of a system (even one you haven't implemented yet).

What if your manager asked you for an estimate of how long it would take to load a million new records into the database and index them? It would be nice to know whether you'd have to take the system down for an hour or for a day or for a week.

What if the performance of your code was slow and you wanted to know whether it could possibly be improved, and by how much. Knowing the theoretical limitations of the algorithm you were running (e.g., sorting takes at least O(n log n)) could tell you what kind of optimizations you could reasonably expect to make or whether you needed to invest in faster hardware.
This team of about 10, was it at Google or elsewhere? Wasn't sure given the higher-level context.
Your comment lacks context. Do you mean parseability of perl has never been a goal of perl? If you read the article, you'll see it was the goal of the author, which is why he wrote this proof. So I'm not exactly clear what you're trying to say.
Let me recommend Yeoman plus Angular. Yeoman is that extra step above and beyond basic Grunt. Integrates Bower so your common components stay separate, then builds out your stylesheets and JS like they should be for deployment. It's a nice way to develop client-side apps.

Then give Angular a shot. I'm not a JavaScript superstar, but it was pretty easy to pick up Angular and run with it. I love how they've organized directives and services. Really lends itself to building reusable components for your apps. Just wish the docs, particularly around testing, were a bit better.
You can't simply asm.js'fy LuaJIT2 because it has an interpreter hand written in assembly and it generates native code to achieve peak performance. You can only asm.js'fy a normal Lua interpreter which is up to 64x slower than LuaJIT on benchmarks, when compared natively. So asm.js'fied Lua will be up to 128x slower. Does not sound that impressive...
Matt Might's illustrated guide to the PhD sort of shows this quite succinctly [1]. I don't think there are any memorable PhD theses that significantly changed anything, save for Shannon's. World-changing researchers do exist, but I think they are created after they obtain their PhD, rather than before; it's unreasonable in my eyes to expect anyone to make such significant contributions in the infancy of their research careers.

[1] : http://matt.might.net/articles/phd-school-in-pictures/
The startup company I'm working on writes unit test. But in my own personal projects, as much as I know that it's a good practice, I don't. I just don't seem to like unit tests. I also want to finish the features I like first and then just test it in real use. I do functional tests, but not unit test.
Maybe after this discussion PG will write an article that going to the uni is not such a bad idea after all :)
Mac Hard Drive Failure Predictor
The first green tick apparently does not test for username existence, but only an acceptable username format.

I think there may be interactive attack models against logins where you separately report "this user does not exist" from "the password was not correct" -- somewhere in the back of my head is a "general rule" that you should just report "login failed" in both cases. However I do not recall the details. It might be worth contacting someone who has worked on real-world implementations of the Secure Remote Password protocol to know what exactly the threat model here would be. (I'm choosing SRP only because I know that I've seen SRP implementations generating deterministic 'fake keys' for users they do not recognize, since SRP requires a user-conditioned response from the very start of the protocol.)

On the other hand, you could probably create a system which allowed interactive password checking without revealing the password and without allowing for easy brute force attacks. The idea would be to combine a slow one-way memory-hard function f (like scrypt) and a zero-knowledge login system like SRP.

The idea would be that I would send you all of the detail needed for a full key negotiation except for the verifier V that you're supposed to finally get -- i.e. the quantity in the zero-knowledge proof where you go "and if that equals V then I accept the login." Instead I'd send you f(V), so that I am not revealing my hidden data, and so that it takes you, say, 100ms to try any password -- providing a sort of instant feedback for 'normal' users while suitably strengthening them against actual brute-forcing.
FWIW, the C preprocessor can be used to calculate PI as well:

http://chaos-pp.cvs.sourceforge.net/chaos-pp/order-pp/exampl...
I've seen this question before, and it always seems to be phrased in a way that implies a) that tech people aren't ideas people, and that b) tech people are just a 'resource' that the 'idea man' (aka. the 'real' founder) owns. As in 'Oh yeah, look at my awesome software. Oh that guy? He's just the one that, you know, wrote it all'.
I think we as techies owe it to ourselves to be flipping this on its head, and asking questions on business sites like "How to find a business cofounder?"
I recently started working in a coworking space full of startups. I occasionally overhear ludicrous conversations where an 'idea' person, with a lame idea, is trying to find a 'tech' person for some piddling share of the equity.
I definitely think there's a huge advantage to being two instead of one, but I also think it should be a balanced one, where both people contribute to expanding an idea, and both truly own the idea, despite who initially started out with it.
Debian 6

Source: http://www.theregister.co.uk/2013/05/10/iss_linux_debian_dep...