skysight-inc/HackerNews huggingface dataset:
> Has some cool feature actually, like Blocks etc.

The blocks are kinda crummy though, and the verbosity is definitely verbose. `enumerateObjectsUsingBlock:` is a far cry from Smalltalk's `do:` (and its signature is awful too, even more so due to ObjC's lack of generics)
> either you implement them partially and have gaps in your semantics so that returning from a function whose stack frame is no longer active raises an exception

Exactly right. That's the one nasty corner case I know of. I don't know how often it comes up in practice. I believe Ruby handles it by trying to make blocks not-very-first-class so that it's hard to capture one and have its extent outlast the outer stack frames.
It makes no sense thinking that they just need to understand their lack of rationality. Like Apple and North Korea, they do, say and claim whatever they want because they get away with it.
A custom application for each third level domain name
It's called the choice of capitalism for the poor. Basically get exploited or don't eat.
Microsoft's "No Compromises" Mantra
Other - please, specify
The only one I'm listening to at the moment is nodeup:
http://nodeup.com/

The podcasters are some of the central figures in the node world and always have useful content.
I think you're right. Because we're so close to the app, we know exactly what each icon means and how it should be used. And once someone gets past the learning curve, everything starts making sense, however I guess we're losing a lot of people who don't want to spend any time trying to guess what different elements are for.
Objective-c is slightly strange compared to other languages but its really just another language anyone can pick up if they put the time and effort into it. Just like you decided to learn clojure or ruby or whatever put some time in, and you can code in any language.
Discoverability in Designing for Touch
Eh, that's putting it a little too strongly. Haskell is a nice language, but it still doesn't protect you from all your mistakes. The easiest way to extract the value in Haskell is fromJust, which simply errors if no value was returned. I do agree that Haskell makes it more natural, though.
UX Happy Hour
not necessarily. you could implement these as function calls with no return addresses (think goto-s or JMP instructions). If you never need to return from some of those functions, there's no need to keep an entry in the call stack for them.
Returning the most precise result types (both collection _and_ element type) is a requirement. If this wouldn't be required, the problem would be much easier.
No problem, as long as they get the same treatment that other people who've used the same defense get.
Maybe the RIAA should take a lesson from the Matt Cutts/Google Chrome smackdown a week or two ago.
FWIW, 92% of WordPress users we surveyed are using it as a CMS. People seem to like to say "it's just blogging software" to put us in a box, but people are using it for so much more, and most much happier than the OP.
Your comment greatly changed my views on advertising.
Sometimes it misses, although in some cases I think it might be related to age: after a certain time it's fun to revisit and given that the base changes no doubt some current readers weren't around when it was last posted.
I don't disagree with your points, but now that we've established that, that is why your original example does not solve the problem as presented in the post. The problem inherently has to do with statically inferring types.
Well, there are a lot of different implementations of Javascript.

You can absolutely download the source to Google's v8 javascript engine (http://code.google.com/p/v8/ ), or the implementations that Mozilla has built over the years (https://developer.mozilla.org/en/SpiderMonkey and http://www.mozilla.org/rhino/ ).

EDIT: Yeah check the comment below regarding tracemonkey rather than spidermonkey.

It should also be noted that Javascript is a specification first and foremost (unlike Ruby which is defined primarily by its reference implementation). It's worth reading through the standard: http://www.ecma-international.org/publications/standards/Ecm...
An alternative that is not as well known is ExpressionEngine. FWIW, we've done a slew of EE installs and a few WordPress intalls and clients that have made the switch from EE to WP have loved it. The admin UI is attractive for end users, and when it comes to theming, designers love the flexibility of the layout variations and front-end developers can actually implement said designs without hacking the EE theming system. This is definitely not the case with WordPress.

Here is a great blog post about the transition from WP to EE written by one of our designers - http://www.viget.com/inspire/wordpress-to-expressionengine/

and here is another unique EE site that shows the flexibility of its native theming system -

www.teamviget.com
Show HN: Publish2Social - Schedule and Publish to multiple social media networks
Yes, Carmack did like NeXTStep a lot. With that said, most of his career Windows was his main dev box. Even post Doom he went back to Windows as his main desktop:
"The upside is that windows really doesn't suck nowdays. Win 95 / NT 4.0 are pretty decent systems for what they are targeted at. I currently develop mostly on NT, and Quake 2 will almost certainly be delivered on win32 first."
http://rmitz.org/carmack.on.operating.systems.html

And more importantly, as it relates to DHH's statement, excluding Windows developers isn't like some odd niche. It's probably a healthy percentage of the best developers in the world. Fortunately for DHH he's at a webdev shop where pure coding skill is probably less important than cultural fit.
They tried that with ".mobi", while the rest of the world went with "m.".
Finally! I was wondering how to do this!

On a real note, napping changed my life. And when I had my own business, it really helped productivity to have a nap in the middle of the day. Now I work for the machine, and naps are unfortunately not allowed.
Also, Lisp has (return-from) which lets you do a non-local return by specifying which enclosing function to return from by name.
This is the first I've heard of it, but a quick glance at its website suggests that ProcessWire may be very promising. Do you have any additional thoughts on it, having worked with it before?
Totally agree. "You are the product" is such a reductive, partisan talking point that at this point it's actually a pretty good filter for intellectual honesty and critical thinking.

I wrote a whole blog post about it here: http://blog.byjoemoon.com/post/9910020865/you-are-the-produc...
Notepad++ was one of the few bright spots of my erstwhile Windows days, and I still wish for it when I occasionally find myself using Gedit for quick note taking. It was sooo fast with just the right features and nothing supurfluous. But I could never go back to it from Vim now.

As for uninstalling issues, if you can't use the package management tools to uninstall (you compiled from source and/or manually installed?), in the future try using GNU Stow or xStow to group all the pieces in a single directory and then symlinking them to the various system directories. It's brilliant. http://www.gnu.org/software/stow/
To Ubuntu's CEO
> what's to be done?

use "their"
I like Ruby. I spend most of my professional day writing Ruby code. I'm definitely not against the idea of adding Ruby as a first class language.

However, Objective-C is similar enough to Ruby that people already well versed in Ruby should have no trouble just using Objective-C. At least for me, when I realized Objective-C was essentially Ruby with C-style syntax, it immediately made sense. I guess YMMV.

The real hard part is learning the beast that is Cocoa/Cocoa Touch. I was able to learn Objective-C in minutes, but learning the frameworks took much longer. You are going to have to do that no matter what language you choose, unfortunately. The APIs have been reasonably consistent across all of the languages they have been implemented on, so I don't think choosing Ruby for your project is really going to speed up the process all that much, if at all.
In Germany, it's way below $250. According to GULP, the largest freelancing website here, the average is around 71EUR/h (around 90USD).
Why won't they be able to afford an iPhone? Are you are implying that they can afford an Android phone because they will be $0 if you sign a contract? iPhones have this option nowadays as well.

What makes an Android phone easier to get a hold of compared to a iPhone? Both phones are $500+ if you get them standalone.
That's not the problem, it's a problem. That is, it's a problem in this discussion, but I feel it has been dealt with well. The author's main point, though, was not about the specific example. That was to illustrate his larger point, which was about the complexity that arises when rich features interact.
4. A simple compiler that sometimes requires a type annotation.

> Those are your only options. Reasonable people can disagree over which is preferable.

Ah ok. Being right seems to be more important to you than having a honest discussion.

Have fun, I'm out.
I find Obj-C elegant in the sense that it reads like an explicit english sentence:

NSMutableURLRequest *request = [NSMutableURLRequest requestWithURL:url cachePolicy:NSURLRequestReloadIgnoringLocalAndRemoteCacheData timeoutInterval:60.0];

If you've never used an NSMutableURLRequest object before, but know how HttpRequests are made, you can figure out what's going on without having to dig into any documentation.

Many languages I've seen (C in particular) hide that explicitness. You call someFunction(arg1, arg2, arg3), but what do arg1, arg2, and arg3 do? Can you pass a 4th or 5th argument too? Unless you've memorized what someFunction() does, you have to dig into the docs, which makes the language harder to read. Obj-C method calls always list "every" available parameter, regardless if its used or not (e.g. nil).

------------------------------

Obj-C takes up a lot of horizontal screen space. It works best on high-resolution widescreen monitors, with a modern editor, and modern mouse, both supporting vertical AND horizontal scrolling. Limiting lines to 80 characters, or anything really, destroys its readability.

The most unreadable Obj-C code I've seen is usually formatted this way. Google's Obj-C code is a nightmare to read; they limit it to 80-characters (http://google-styleguide.googlecode.com/svn/trunk/objcguide....). Great for a 1980's terminal, not for modern 2560x1440 displays.

Frankly line-length should not be the job of the programmer writing the code, but of the IDE/Editor displaying it properly on-screen. When you say "all code must be 80 lines long", you've forced that upon every programmer regardless if it's a good decision or not.

It's like decoupling the Model and View. The Model is the actual code written, where the View is how it's displayed. Programmers should be able to customize how their View looks using their IDE/Editor. When you hard-code the View into the Model, you break decoupling, and force everyone to use the same View.

Most Editors/IDEs let you customize the view somewhat, like color-schemes and "wrap text". But I haven't seen a "complete" decoupling of the model (code) and view (how it's presented) yet, in any IDE/Editor. Someone please correct me if one exists. This is a feature I'd "LOVE" to see in all IDE/Editors and programming languages, as it will make verbose languages like Obj-C much easier to read based on the programmers preference.
Do you have it straight? From the article: "Instead of the raise they requested, these workers were given the following ultimatum: quit with compensation, or keep their jobs with no pay increase. Most quit and never got the money. That's when the mass suicide threat came in. The incident actually caused a factory wide shutdown, reports Record China. "
> You don't need to be sympathetic with the workers either.

Of course not, they are just accepting 36 hour shifts because they are bored. Not because the alternative is starvation and unemployment.
They probably did the wrong thing too. If they just "identified" and fired a random person for it and made it public, they could continue with their tactic. Now they can't do that anymore - the next well known "downloader" lawsuit will use the same line they did...
That's not the analogy I was making. I was saying that there is a certain class of worker who, despite their bad conditions, is probably better off than they would be without the job. Forced or free doesn't factor into it; the question is to what extent supporting their employer is a moral act. Obviously forced labor is worse than free, but there's a continuum of ethical labor practices that both slavery and Foxconn (and any other employer) reside on. I was speaking to the ethical quandary of supporting companies on the low end of that scale, if the options for their employees are something even lower.
Usually the masculine form is used as a gender-neutral pronoun. While correct, with no contextual need to deviate from the norm, I find the title unnecessarily distracting. But not as distracting as mismatching number and writing "their time" instead.
Let me unpack it for you then.

There is a reason XML, the semantic web, linked data failed to really change the data world, whereas hadoop did. The reason is computation.

The problem isn't data interchange formats and ideal representations, the problem is being able to compute with data. Distributed computation can then be used to solve all the other problems.

Case in point: Slurping data out of databases. Apache Sqoop leverages the primitives provided by Hadoop, in terms of partitioning and fault tolerance, to make it easier to do massive data transfers out of existing databases.

Another example of a solution coming from the hadoop perspective: Avro. It beats the pants of off XML as a data interchange format, precisely because it makes computing with the data (which is the ultimate point) easier.

Now, there is a reason I called Hadoop the integration point. It is becoming a general purpose computation system, which at the same time is also the datawarehouse for organizational data. So rather than dealing with the details of proprietary commercial systems, programmers can target applications to the open-source hadoop ecosystem, and have those solutions be reusable and customizable on a large scale.

The "publishing solution" would of course deal with access control, business logic, freshness, etc. That is exactly what I'm advocating be built.

Individual pieces of data may not be big data, but the aggregate problem still is. In fact this is exactly the Wolfram Alpha case: tons and tons of little datasets that add up to a lot of headache.
Passion: Leadership Asset or Liability?
Thanks, that is exactly what I meant.
Nah. Ruby just raises an exception in this case:

class BlockInvoker
def initialize(&block)
@block = block
end

def invoke
@block.call
end
end

BlockInvoker.new { puts 1 }.invoke

def get_block_invoker
BlockInvoker.new { return }
end

get_block_invoker.invoke

I tried to cover this a bit in my post. For callbacks, this semantic is clunkier.
> What about it makes it painful?

1. Verbose, it's very hard keeping ObjC code in 80 columns (if you linebreak too much it's completely unreadable)

2. Lack of generics make the code not feel as safe as the verbose presence of types everywhere would make you think

3. I hear Xcode 4 improved things (and appCode is an actually good IDE), but Xcode 3-generation tooling really is quite terrible, I miss having errors display as I type. Also the autocompletion is garbage, it's barely as good as dynamically typed languages

4. NO NAMESPACES

5. Many solutions feel old/hackish: separate interface/implementation files, macro-looking code (@property/@synthesize never feels right), objective context ("[" and "]", especially as you're repeating them all the bloody time), the severe dichotomy between objects and values or structs requiring things like content wrappings/unwrappings in NSValue (and then there's bloody `id`, which does not look like a pointer but is still an object)

stuff like that. I don't really feel good coding in Obj-C, the frameworks are very complete and often wonderfully thought but I really have a hard time enjoying the language.
> Google buddying up with Verizon to change net neutrality in the mobile space

Nothing changed about net neutrality in the mobile space. We went from "no net neutrality" to "net neutrality in wired networks, but not wireless networks".
I use both Java and Obj-C at work. Objective-c suffers from its C heritage.

1. Pointers (just not useful or needed these days)

2. Memory-management (you don't get ARC unless you're happy to not cater for users using <5.0 (apparently this may not be true. thanks for the comments), and even with ARC you still need to do more than you do in Java)

3. Message-passing (Not bad per se, apart from this: you can send any selector to a nil object, meaning your app will fail silently in many instances. And that is huge.)

4. Header files (the #import is an advantage over usual C, but it's still a pain to remember to import any object before using it)

5. A hodge-podge of syntax: it's smalltalk-inspired syntax, with the more recent dot operator, with the usual C syntax.

6. Painful process of defining/declaring variables. Usual initiallisation, the @property, then @synthesize then initilise it in init: then nil it in viewDidUnload:, then decalloc it in dealloc:.

7. masklinn's point about Namespaces is important, too. Making a library with the standard three letter prefix on every class seems very hackish.

8. masklinn's point about the 'id' variable catch-all also: its very often misused. And your code is full of class checks.

I can live with those things. And that's even if they do make Java look like a nice language. What I really hate is Xcode. (And used to HATE eclipse before encountering Xcode)

1. After you get use to Eclipse's intellisenseque features, using Xcode is like wading through treacle. As one example, initilising a new member field is 1/2 a second job. In Xcode, you have to do what was in the last bullet point. For. Every. Single. Variable.

2. It's debugger/variable inspector, compared to Eclipse, is substandard.

3. Xcode crashes. Often.

4. It just doesn't feel as fast as Eclipse.

5. The debugger can hang on the iPhone a lot, meaning you need to turn it on and off quite often. It's okay in the simulator, I've found.
In case you're wondering, below is 1 paragraph of lorem ipsum. You won't see the first line until you paste it somewhere.

Do your layouts deserve better than Lorem Ipsum? Apply as an art director and team up with the best copywriters at Jung von Matt: www.jvm.com/jobs/lipsum

Lorem ipsum dolor sit amet, consectetur adipiscing elit. Aliquam tristique velit eu neque ultricies in rhoncus nisl aliquet. Integer arcu nulla, cursus quis placerat non, pretium vel velit. Donec lobortis vehicula lorem id sollicitudin. Sed ultricies tempor quam at faucibus. Aliquam erat volutpat. Nulla convallis risus vitae libero ullamcorper vitae mattis felis pellentesque. Praesent et adipiscing mauris. Nam at tortor et quam auctor semper. Duis mollis venenatis sapien, vel accumsan est interdum porttitor. Phasellus justo turpis, elementum vitae vestibulum ac, hendrerit laoreet urna. Nam vestibulum erat nec nisi tincidunt a sodales nisi tincidunt.
Estimating the Cost and Schedule of Mathematical Software
I still think we need to split up hosting, editing, etc: http://joshua.schachter.org/2009/12/blogging-tools.html
I'm glad that this provides scientific justification for that napping danger zone between 45 and 90 minutes. Having taken naps that have ended in that precarious time span, I can attest that it feels like you're worse off than when you started.
Raspberry Pi: We’ve started manufacture
Wait a year.

Ubuntu has a very powerful tendency to slowly develop crud and become unusable, until you just need to start from scratch and re-install the OS.

Not sure if this has changed, but laptops tend to be a mess with Ubuntu. Things like closing the lid and going into sleep mode would fail seemingly at random.
Some similarly useful tips in How To Report Bugs Effectively also apply to IRC http://www.chiark.greenend.org.uk/~sgtatham/bugs.html
Explained: http://news.ycombinator.com/jobs

"All the jobs listed here are at startups that were at some point funded by Y Combinator. Some are now established companies. Others may be only a few weeks old"
> They can go back to farming

Where? At the government-mandated pick-a-plot-land-for-free fair?
Ditto. For me, the 20 minute investment in a post-lunch nap pays back manyfold in increased productivity (to say nothing of health and general well-being) for the rest of the day.

Finding a place to nap in an office an environment can be tricky, but if you start thinking of your nap as an important work tool and not an embarrassing indulgence, you can usually find a way to make it work. Drop a few bucks on a good pillow, blanket, sleep mask, and/or white-noise headphones -- whatever's important for you -- to keep at your desk. (For me, the sleep mask is critical. YMMV.) Get creative with your sleep position -- couches are great, but I've made it work lying on the floor with my feet up on my office chair (suitably chocked so it won't roll away). The key point is, don't be afraid to ask the work environment to adapt to your nap, rather than vice versa.
Genuinely suicidal people don't threaten to commit suicide, they just do it. These people tipped their hand by coming off the roof without Foxconn conceding to their demands. If idle threats to commit suicide are a surefire indication that someone's being mistreated, then millions of teenage ex-boyfriends and ex-girlfriends are mistreated, too.

Threatening to jump off a building shows even less conviction than a genuine hunger strike (which will kill you more effectively than picketing on a rooftop making idle threats). IRA terrorists have engaged in hunger strikes to get released from prison--does that mean it's abusive to imprison terrorists?
Search, plus Your World
That can still be 5 different people in one house. Or several hundred in a neighborhood.
My post wasn't a direct response to your article, but rather thebandrews' point about preparing for interviews.

And I'm not saying you shouldn't prepare for interviews. I'm just saying that companies that evaluate a candidate based on how they "perform" in an interview vs. trying to really get to the root of how they would perform in a job are doing themselves a disservice, and may be losing some good candidates because of it.

And if this is happening, that company should change their interviewing strategy to focus more on what's important, and get rid of anything that may get in the way of evaluating that.

Take your point on writing code on a whiteboard vs. writing on a notepad, just for example. To your point, it may be unnatural to code on a whiteboard. But, to me, it's also unnatural to code on a notepad. Actually, I hate handwriting altogether. I prefer typing a thousand times over. So in order for a company to really see how I code, they would hand me a laptop, or even better, allow me to use my own.

Of course, there are arguments to whether that would even be a truly accurate evaluation. My point is -- and again, this isn't necessarily in direct response to your post -- that good employers know how to get to the root of someones abilities, without letting these interview-specific strategies get in the way.

Edit: Disclaimer, I did not vote you down. :)
Siri was able to answer the "where were you designed?" question with "Designed by Apple in California", so it may or may not be just joking response to a nonsense question.
Google's Results Get More Personal With "Search Plus Your World"