skysight-inc/HackerNews huggingface dataset:
Don't take that in the literal sense -- of course, anyone who is hiring someone is technically filling a position. Think of this as a classification of a company's motivation to hire in the first place.

I found companies that were "filling positions" were those that had a previous role defined, and now needed to either replace the previous owner, or add to the organization (they had budgeted for it, for example.) These tended to be larger companies, and the focus for the job was the role. In these cases, the role had largely been pre-defined.

The short-list of companies I spoke with that were trying to "solve a problem" didn't think about what role someone should fill, but rather what capabilities a candidate could bring to their team. These companies I found were often smaller (less than 100 employees), although I'm sure it could apply to larger ones. The difference with these companies is that their focus (from my vantage point) was not on organizational structure, but rather on thinking about how a candidate could augment their team.

It was very eye-opening, and once I picked up on that pattern, I began to ask the "right" questions.
cameras are sensitive to IR and usually have a filter to block it, since it it usually unwanted. you'd need extremely and impractically powerful IR lights to do anything useful.
Why do you put avoidance of OOP down to fear? Maybe it's down to an understanding that OOP is often overused and should not be the paradigm-by-default. Disclaimer: I don't actually know what the cause is in this case, nor do I think that OOP should always be avoided.
Could you elaborate? Have you seen someone intagrate a javascript interpreter the same way with vim, or are you saying that modal editing is enough of a productivity boost to make up for it's lack?
Equity Crowdfunding: The Biggest Change For Startups In The Past 80 Years
Sorry if I wasn't clear about this, but you can embed classical mathematics in a type theory with univalence. If you look into the HoTT book, there is a chapter on set theory in type theory. The general form of excluded middle is inconsistent, because it would collapse the structures on which univalence is built.

This means that classical mathematics still works as expected, so long as you have the assumption that you are working with things that are "set-like". Additionally you can make any type "set-like", since this amounts to manually collapsing its equality type.

However... the truth is that most of the time excluded middle is unnecessary (in a type theory). Having nice equality types is so much more useful that, honestly, you are not making an informed decision.
Really?! Then you are not an European I guess.
My ~solution~ hack is to fasten a couple of small IR LEDs into my hat and flood the cameras with lots of lights ;)

You need to consistently be at the proper angle for this. That and once again, it's only useful for the most primitive cameras that have a constant IR level.
I'm giving a talk at FOSDEM: NixOS, declarative configuration Linux distribution
What would you like me to explain? I'll do my best to present NixOS stack in 25 minutes talk. Anything particular you would like to know from the stack?

- Nix is a purely functional package manager. This means that it can ensure that an upgrade to one package cannot break others, that you can always roll back to previous version, that multiple versions of a package can coexist on the same system, and much more.

- Nixpkgs is a large collection of packages that can be installed with the Nix package manager.

- NixOS is a Nix-based Linux distribution. Thanks to Nix, it supports atomic upgrades, rollbacks and multi-user package management, and it has a declarative approach to system configuration management that makes it easy to reproduce a configuration on another machine.

- NixOps, the NixOS-based cloud deployment tool

- Hydra is a Nix-based continuous build system.

Cross-post from reddit.com: http://www.reddit.com/r/linux/comments/1st3vz/im_giving_a_talk_nixos_declarative_configuration/
- DO NEVER ever try to teach about objects as representations of real-world things. And for the love of god, do not give out modelling assignments where "Human inherits mammal" is an answer

I have to disagree with this. I think this is exactly how to think about this.

I once explained the shift to OO to an older gent who was familiar, not just with ancient scientific programming, but also with building a house. I told him that the idea was that code was so large and complicated that it was divided up among teams with each team getting specific parameters that their code had to fit. He said, well of course.

Then I said it was much like constructing a house. You had to put the frame up, and know where the windows and doors would be, but the details of the windows and doors could be decided later. Every door had to be able to respond to an "open" command and a "close" command, some may have a "lock" command, and so on, but the builder of the door worried about getting that stuff right. All you had to specify were the dimensions and the direction of the door.

Now this was a pretty technical person- and perhaps doesn't qualify as a beginner, but I find, in general, real world metaphors to be powerful for teaching.
Not just source code either. The Apple ][ came with a hardware manual containing schematics of the machine.
Or just let YouTube stabilize the video for you.
http://ternjs.net

Tern is a stand-alone code-analysis engine for JavaScript. It is intended to be used with a code editor plugin to enhance the editor's support for intelligent JavaScript editing. Features provided are:

*Autocompletion on variables and properties

*Function argument hints

*Querying the type of an expression

*Finding the definition of something

*Automatic refactoring

There is currently Tern support for the following editors:

*Emacs

*Vim

*Sublime Text

*Brackets (built in to the base editor)
> I don't think she deserves "slut-shaming" at this point

At exactly what point would someone deserve that? To me, the entire concept is entirely alien and I consider anyone that consider such behaviour tolerable at any point at all a big ass-hole that isn't fit for society.
I read, and upvote the deserving posts.
Usability note: after a few clicks through this (so my path had a few entries) I instinctively clicked up a few levels in the path expecting to be taken to that point. Instead, that entry was appended as another child.
All of that is true unless it is, say, cache data that you can afford to ditch if the format has changed, and you validate it after reading (say with a carefully structured "magic" value).
It leads naturally to pre-monogamous, primitive, dysgenic, and in practice anti-feminist social patterns and has divided men between an "alpha" contingent who objectify and degrade women, and an "omega" contingent (cyberstalkers, doxxers) who hate them.

Lots of big words, but always the same adolescent logic: "the culture" somehow prevents male nerds from dating. So it's no surprise that they abuse women.

How is it that so many of us manage to actually grow up? Most of the male nerds I know today have families. It's because there is no such thing as an "alpha" or an "omega". Those are concepts are invented and reinvented in different contexts to let people off the hook for their own thoughts and actions. It's not about taking personal responsibility for... what, being on the same Internet as a person who wrote a sex blog? --- no, it's that they're omegas victimized by a culture that promotes Game.

Horseshit.

The problem as I see it is much simpler. Variance in human cognitive ability ensures that there will always be people damaged enough to harm others purely out of blind, undirected malice. The Internet (a) creates an affordance that makes harassing women the simplest way to do that and (b) amplifies them. You don't need a conspiracy theory about "Game" and "alphas" and "omegas" to understand what's happening; people that used to spend their lives living in their grandparents basement torturing animals for fun now spend that time doing something else online.

What I don't understand is the urge others have to rationalize their behavior.
Have her learn a language that is not the flavor of the month. Java, C#, C++, etc. Those languages are always in demand and are mostly used by stable companies. She may then learn Ruby, Python, or JS. Those are rather simple after learning how to program with the others.
Sorry, but what set of Emacs plugins are able to offer what Netbeans does for HTML5 development?

https://netbeans.org/features/html5/index.html
Python advocacy aside, I agree that OOP is best taught when it "comes naturally" and NOT the first thing programmers should be learning. That is, the ideal sequence of concepts I think would be (along with a possibly contrived but relevant example):

1. Very basic, sequential computation. Add two numbers.
2. Conditional computation. Find the absolute value of two numbers.
3. Computations over homogenous data: Arrays and loops. Find the average of the absolute value of a set of numbers.
4. Computations over inhomogenous data: Structures. Find the area of a set of rectangles.
5. Computations over "even more inhomogenous" data: Objects. Find the area of a set of shapes of different types, and find the centroid of them.

That's where you ask "how would you do this with what you've learned so far", and the learners should start to build different structures with a lot of similar aspects and duplication of code (I realize I didn't explicitly talk about the value of functions/procedures above, I guess it'd go somewhere after 3), and then you show them how much more straightforward it is to do with OOP. Now they know the value of OOP and what "doing it without" would entail, and you end up with a bunch of more knowledgeable programmers who won't needlessly create baroque class hierarchies and write more code than they need to, but will use those abstractions when they have value. There is a huge difference IMHO between e.g. being taught dogmatically "you MUST use functions because abstraction is good" like it is something you should take at face value, and being taught by being given a problem in which you do not know about functions at this point and thus write lots of duplicated code and then being shown the value of eliminating that duplication via functions.

I've seen way too many learners create half a dozen classes with a ton of methods in them when given a problem that could be solved in a single function of a few lines, then have trouble figuring out what to put in the method bodies... it's completely backwards! No matter how much "architecture" you manage to create with deeply nested objects, in the end all the functionality of your code is essentially based on a series of statements executed in sequence, much like they would be in a purely procedural language. The fact that many otherwise highly-regarded educational institutions are churning out programmers who can create dozens of classes with dozens of methods in them, and then not know what goes in those methods, i.e. the actual "meat" of the computation, is something I find highly disturbing.
I strongly disagree with the OP but if that is how they feel, they have a right to state it.
Could you elaborate or provide links to examples of what you mean by solving this with codata?
Yes. If only the victims would change, everything would be OK. Silly victims.
Programming is hard. There's no magic bullet. OOP is fine. Functional is fine. Procedural is fine. Every generation of programmers started with something different than the previous and turns out fine.

At the end of the day, every abstraction leaks so the student has to have a good working mental model of computing. And your first programming langauge does not dictate your career. You're expected to keep yourself up to date and have continue honing your craft.
That's the theory, sure. But in practice, if you know all your targets support the right "#pragma pack" and "__attribute__((packed))" and other markers that you use - what's wrong with making use of them?
The problem is the design paradigm where you enforce an arbitrary fixed hierarchy on real-world data.

This doesn't work for several reasons:

* In the real world there are multiple overlapping hierarchies, which have different uses. Human 'isa' SentientBeing as well, which may be a much better heirarchy for modelling communications with aliens and robots. Most OOP languages either don't handle this at all, or handle it badly.

* Your hierarchy will almost certainly have to change (you'll be wrong, or new requirements will come along). Frequent major code breakage / refactoring is the likely result. If you also need to persist data across versions, you're in big trouble.

Property / prototype based methods are in general much more flexible for real world data.
Why should you never try to teach objects as representations of real world things? Just curious.
If they actually have lower expenses than competitors, they may be competative on margin rates. If that is true, then anyone who manages to make some money trading small amounts and wants to scale up is likely to stick around.
Where on earth do you get the mental illness from? Teenagers are not 'mentally ill' because they do things that older folks consider unwise. There is a difference between having different beliefs and having unhealthy beliefs.
The proposed class hierarchy for different types of "game objects" is exactly the type of hierarchy which will bite you in the ass very soon when adding more features, an entity-component-system would be a better solution for this specific problem (composition instead of inheritance). Newbie programmers should never be taught this "animal - cat - dog" nonsense IMHO because this approach of modelling software after real-world objects doesn't work for anything slightly more complex. For instance, what if you have two different enemy types which both need to implement a common feature but differ in others? Please don't say 'multiple inheritance' ;) This doesn't mean that OOP is bad at all IMHO, just that it shouldn't be treated as a holy grail (applies to all design principles), and doesn't mean that you have to go all-functional. All IMHO of course.
If you view OO as a set of organisational facilities above procedural code, then it makes a lot of sense.
Heritable IQ is a sign of social mobility
Mr Confusion, please write here your real name, let somebody make all top Google results to your name link to always new brutal lies about you, then explain us all how you can not care too much about the opinions of random others.

For the start, I'd like to know what would happen if people start down-voting your posts here, would you delete some? Would you close the account? You see, it's easier, you haven't provided your real name.
No, primarily the people around the victim need to change. Which means beliefs in general, of everyone, need to change. That the victim would then also change is a bonus, which wouldn't even be needed anymore.
Ah ok, you're trolling - I should have realised.
yep there was an epic debate about "objects-first" vs. "objects-late" CS1 curricula last decade. the objects-first folks seemed to have lost, though. here's a paper:

http://homes.cs.washington.edu/~reges/sigcse/basics.pdf
I know it's a bit silly but the thing that jumped out about your comment and the parent comment is the butter. You butter a hame and cheese sandwich? Is this a cultural thing I'm not familiar with? zooms off to google to check
Swappi - swap your fashion
"I told him that the idea was that code was so large and complicated that it was divided up among teams with each team getting specific parameters that their code had to fit."

IMO, this is the first mistake. Code should not be large and complicated; when it is, few things can save you, whether it be the language or paradigm you're programming in, or the structure of the team doing the programming. OOP is a solution to the wrong problem.
This was one of the most pleasurable experiences I had building an app from a book. Kudos to all on the meteor team!
Thanks - much appreciated. I've used Heroku to test a couple of "hello world" apps, but was hoping to use DreamHost's shared server account in order to learn the tricks of deployment for myself.
I've seen some products just bounce back and forth a few cents. I notice this because they are in the non-checkout section of my shopping cart (not sure how it's called on .com). I always assumed those prices change mostly because I get a notification every time and might be more inclined to add them to the "real" cart.
Am I the only one who puts on their 'skeptical hat' when I hear a claim of 'three times more likely'?? Especially when I see numbers as low as 4.4% and 1.4%.

sigh statistics... amirite?
Ask HN: What are some good programming blogs, especially on web dev?
I love that this sentiment is voiced by an anonymous HN resident.
Often, it will be because the projects are older than the warnings. And when the amount of warnings cross a threshold, they will not be fixed.
I'm working on a project with one of the points in mind. Its an API that allows popular embedded cards (arduino, raspberry pi) to message each other through the web. It called bbedy (https://github.com/bliti/bbedy). This is version 0.2, and it is mostly functional.

The aim of the project is to enable the exchange of (sensor) data between devices. It is driven by a simple protocol I'm about to publish on github. The idea came to be when I did not have any way of exchanging data between two raspberry pi projects I was working on. I prototyped a very crude version and it worked very well. I decided to create an open source version that could be easily pushed to Heroku or any Django-enabled web host (like webfaction).
ETA for the project is January 2014. Shoot me an email if you'd like to know more.
Let's put it this way: you are asked to write a program that simulates the behavior of an LCR circuit. Do you create objects to represent the components of the circuit?
How to Hit it Big in Life? Suggestions
This originated from 4chan
Me. I usually read the newest page after reading the front page. There’s a lot of crap and I flag the worst. But from time to time I found an interesting story and upvote it, it makes me happy to find them before they disappear, and I’m happier when they later get more upvotes.
I can't think of a sandwich I wouldn't butter, including peanut butter.
Lapka - Personal Environment Monitor
This is not a well-funded industry with an engineering staff, it is a single lunatic. Subpoena a list of IP addresses from hosting companies, then subpoena the ISPs responsible for those addresses, then have the local police put the kibosh on the lunatics. Yes, it is possible that the lunatic uses a cloaked Internet connection and has flawless op-sec, but the odds are that he is just another raving schizo who can barely remember to pay the electric bill.
http://www.theverge.com/2012/12/11/3726638/lapka-iphone-sens...
> Good luck with that. Subdomains make that basically impossible; even large, established corporations with big branding budgets have difficulty with this.

It's not only anonymous harrassers causing problems - for example, I've had a few magazines (2 mainstream owned by the same outlet and 1 industry magazine) in my country campaign against my name recently, after our company pointed out illegal price fixing in the industry. Now the top google (and bing) results for my name are 2-3 such articles in magazines with otherwise decent reputation, previously my personal web page, facebook page (with 0 friends 0 comments), old university web pages and various old programming projects were the rop results. How do I "clear my name" other than being more active on the web, using my own name (I haven't bothered to blog or post stuff online for various reasons, one of them is that my personal life doesn't belong there), or hiring SEO experts to push more neutral content to the top? I guess I'll just sit it out ...
Nobody would bother to make the top search result point to new brutal lies if my friends and potential employers wouldn't care about the top search result. Which they wouldn't if they would care less about what some random persons on the other side of the world believe. Which they should if they would properly internalize how the world works these days.

I practice what I preach. I'm constantly advocating being wary of information found on the internet. I advocate not caring about what random people think. However, this way of achieving change takes a lot of time. It doesn't prevent a new incident tomorrow or next year. But maybe in 10 years.
My dad does this. I don't get it.
> * In the real world there are multiple overlapping hierarchies, which have different uses. Human 'isa' SentientBeing as well, which may be a much better heirarchy for modelling communications with aliens and robots. Most OOP languages either don't handle this at all, or handle it badly.

There may well be overlapping hierarchies, and trying to capture taxonomy with an adequate analogy to explain the concepts of inheritance to somebody is perhaps not the best way. But to say that you must never enforce an arbitrary fixed hierarchy contradicts the very purpose of inheritance in a good design.

For your particular example the correct way is to have a separate interface called "ISentient" that captures whatever methods and fields are required for sentient communication.

Most OOP languages support that concept.

So you can have a Human that inherits from Mammal, but only Human introduces the ISentient interface. Your "Robot" can then inherit from "Machine" and also introduce ISentient.

A much better way is to use interfaces for most things: use IMammal then override "procreate" so you can account for specie extrema like the duck-billed platypus class, which is a mammal that lays eggs.
Python is Important for the Future of Social Science Research
Why start with computation as a sequence of operations? It might be equally useful (maybe even more useful for some students) to start with computation as a series of reductions e.g. with combinator logic.
First, I disagree with your premise that PHP's flaws can be attributed primarily to lack of OO design. But regardless:

For all its (many) flaws, PHP was (and is) an extraordinarily successful project relative to the vast majority of programming projects attempted. This is in fact a confirmation of the original post's thesis. The theory is that teaching OOP to beginners bogs them down worrying about the architecture of their code before they've had any experience solving problems at the scale where the architecture matters. It's easy for a beginning programmer to waste hours on pointless refactoring that doesn't actually improve their program in any meaningful way, simply in order to appeal to some professor, teacher, or other religious figure's concept of "good code". PHP, on the other hand, said "screw you religous types, we're just going to design a product people will use."

The reason that OOP should not be taught to beginners is not because it's a difficult concept. The reason OOP should not be taught to beginners is that it is an advanced concept. There are many other important fundamentals that can come first.
Git is designed for project maintainers, and a lot of the complication is necessary for them (that view helps me, at least)