Hacker Newsnew | past | comments | ask | show | jobs | submit | more lambda's commentslogin

Harvard College is the undergraduate institution. It is one of the most prestigious undergraduate colleges in the US.

However, it is but one of several schools that make up Harvard University, which include graduate schools like Graduate School of Arts and Sciences, and professional schools like Harvard Business School, Harvard Law School, and Harvard School of Medicine.

There is overlap between the different institutions at Harvard; the Faculty of Arts and Sciences teaches undergraduate classes at Harvard College, graduate classes at the Graduate School of Arts and Sciences, and performs research.

Harvard Extension School differs from many of the other schools in that it is not selective; anyone can simply pay to take a class. That means that merely attending Harvard Extension School confers considerably less prestige than attending Harvard College or one of the other schools at Harvard; all it means is that you paid for some courses.

Saying you "dropped out of Harvard" makes it sound like you were really brilliant and had a lot of promise but founding your own company held even more promise than finishing your degree. Saying that you dropped out of Harvard Extension just says that you took a few night classes and never really got around to finishing anything.

I took a few courses at Harvard Extension in high school. Some of them were really good, some of them not so much. A top notch school tends to offer a much more consistent program than Harvard Extension school. I've also attended another Ivy League school (group of very prestigious, fairly selective schools in the Northeastern US) as a full time student, as well as a flagship state school, and I can say that based on my personal experience, I'd rank Harvard Extension a little below the state school (which also had some really great classes and some mediocre classes), not up with the Ivy League school.

More info on all of the schools that make up Harvard University: http://www.harvard.edu/schools


You generally create the test in a new file that won't be affected by checking out older code. If you need to change some part of your build system or test system, have the test be a patch that can be applied, run the build, run the tests, and check the results.

As far as having other uncommitted changes; just stash those. "git stash" is a tool you should use very often for any time you have uncommitted work that you need to clear out before doing some other git operation.


For one, it means that you don't need to have a precompiler step in the development process. You can more easily edit the value inline in your browser's developer tools. You can more easily put together simple static sites.

Another is that you can use it in conjunction with calc(), which you can't do in a preprocessor. Take a look at some example use cases for calc, which can't be done in a preprocessor: http://css-tricks.com/a-couple-of-use-cases-for-calc/ Now instead of just using constant values in those, you can use variables. This can be even more powerful for responsive designs, because you can set the variable to different values based on a media query.


Not wanting to execute arbitrary untrusted code on your machine? While there has been lots of good work put into sandboxing browser by the browser vendors, the ability for attackers to run custom code within the browser makes many exploitable vulnerabilities a lot easier to exploit. Things like the various privacy leaks based on cache timing, visited link styles, and so on, or just exploiting buffer overruns that have been protected against by address space layout randomization but with arbitrary code the exploit can try the same thing over and over again with different size inputs until it finds one that works.

Running JavaScript in your browser automatically from any site that you visit is pretty darn scary when you think about it. You can protect from a whole host of vulnerabilities by disabling it, and then whitelisting only hosts which you trust.


> What is left is keeping track what everyone has put in, and what they have taken out.

And that's exactly what Bitcoin is; a secure digital ledger. It's a way to securely and globally record "person A has 10 BTC, gave person B 5BTC, then person B gave persone C 3 BTC" in a way that doesn't allow person A to simultanously have given those same 5 BTC to person D (who, given the anonymity of the internet, may also be person A).

That's all Bitcoin does; it provides a secure way to record such transactions without having a trusted third party who must trust to increment and decrement the right accounts in the right way.


So is that not an impressive solution - if Alice wants to move 100 USD to France and Bob wants to move 100 USD out of France (let's say both want to buy a new textbook) then one could envisage a peer to peer money transfer system.

A site allows bob and Alice to find each other, agree a shared amount to transfer, agree to which end point they will onwards transfers (hmmm this might be the breakdown point) and then record that in the block chain

I think oddly there is still an enormous amount of trust involved - trust that Alice will complete the final important step of giving the money to Bobs silver haired grandmother or whatever


You can actually achieve the same thing with Coinjoin if all involved parties agree. Instead of a bunch of individual transactions, they collectively generate and sign one.


There's nothing wrong with abstraction. But you should use the right abstraction for the job. You don't need a huge PHP web framework, tons of dependencies, an entire package manager, sudo access, and so on to have a simple memory game with a high score backend.

Remember, when you're looking for a job, you're not looking to create some build and forget application. You're going to be working as part of a team. Other people need to be able to maintain your code. For a problem that should be able to fit onto a single page, you don't want to have to browse through a 7 megabyte git repo with nearly 10,000 files in it.

An analogy might be if someone's trying to hire you as a carpenter. They ask you to build a cabinet to demonstrate your skill. You go and find a prefab house frame, an entire prefab plumbing system, and so on, and build the skeleton of a house. Within that, you build a reasonably functional cabinet, though it's kind of hard to judge the cabinet among the entire rest of the incomplete house. How do you think that's going to compare to someone who just went and build a cabinet, and spent the time getting it built really nicely, paid attention to the detail work, made sure the door hung true and opened and closed without squeaks?

Here are a few things that I note at a cursory glance; and notice that I haven't even gotten to the logic of the code, because all of these things are red flags that come up before I am even able to read it:

1. Checking in dependencies to Git. That's not how it you do it; dependencies should be handled by a separate package manager, in which you depend on the appropriate versions of packages. You should never check anything other than your own source code into Git.

2. Your commit messages. Commit messages in Git should follow the format of an email describing a patch. The first line should summarize what the commit does; the rest of the commit should contain a description of why you are doing it. See the following for an explanation of what good commit messages should look like. First from the Git source itself:

http://git.kernel.org/cgit/git/git.git/tree/Documentation/Su...

And then a much more in depth guide:

https://wiki.openstack.org/wiki/GitCommitMessages#Informatio...

3. Inappropriate use of frameworks. You included a lot of dependencies that are unnecessary for the problem at hand. Dependencies have real costs; every extra dependency is something that could break, could have a security bug, could be a pain to upgrade in the future. Now, that doesn't mean to never add dependencies; but do so with a certain amount of care.

4. Simple spelling and style errors. Tabs vs. spaces. Inconsistent spacing: "var _createCell = function( color, id ) {" and "if ( el.className.indexOf('turned-over') > -1)" (note: decide whether there are spaces between parens and their contents, and stick to that choice). You spelled "RESTful" as "restFul". Things like this are seen by developers as canaries in the coal mine; if you are sloppy about the very basic stuff like tabs vs. spaces, are you really going to be mindful of other important things? Consistency of style is important for keeping code readable, if you can't even keep consistent in a simple code interview problem, why should anyone think that you'll be able to do it on a day to day basis when under real deadline pressure?

Here's my exercise for you. If you want to get better, and be able to pass future job interviews, condense this down into as small a codebase as you can, with as few dependencies as possible. I think that you should be able to do this in less than 100 lines of your own code, and only the most basic of dependencies like jQuery and some simple microframework on the server side.

Give that a shot, and then take a look at both for comparison. Which would you rather maintain? Which will be easier to make changes to? Which is easier to code review?


Regarding 1. As far as I know, npm says in it's docs you should add node_modules to your scm because there is no way to install the exact same version through npm on different machines. On the other hand, composer has a .lock file which specifies commit hashes it installed on the dev machine, so a composer install installs the exact same commit on every machine.

@OP: You didn't commit the composer.lock. That means that your code might run locally but breaks on another machine because there might be a new version of laravel 4.2


Can you provide a link to that? That's not how npm works at all. You specify dependencies as a dictionary: keys are package names, and values are versions. They support commit hashes, but do not require them. See: https://www.npmjs.org/doc/package.json.html#dependencies



You haven't been coding long enough if you hadn't had projects that consisted mostly of just that.


I've done almost nothing and I look at my code and wonder that. Yes, I'm doing it wrong.


Both arrow keys and spacebar work just fine.


You're not forced to use glibc on GNU/Linux. You could link against bionic if you want, assuming it runs in a stock kernel.


This is true of pretty much all science reporting (at least, on things that are claimed to have some practical benefit).

I think that the science reporters figure that if they simply report on every successful test, regardless of how far it is from being practical, eventually they will be the ones to have broken the news on "the next big thing".


Guidelines | FAQ | Lists | API | Security | Legal | Apply to YC | Contact

Search: