skysight-inc/HackerNews huggingface dataset:
??

I'm not complaining about code appearance. My code is completely different from his code; I use the same principles as the stuff he uses in K - create a UNIQUE set and check if the size of the unique set is smaller.

Trivial examples have a fundamental failure in that programming in general doesn't scale up without side effects. It's like special effects: If you try to run a scene by creating miniatures, certain effects, such as wind blowing across water, and speed, do not remain the same. You need to tweak stuff endlessly to make it 'look right' and even then there are practical issues.

I get that screencasts can't very well delve into a 3-man-year project. This does not mean that because the issue cannot be represented in a screencast, that it doesn't exist.

Take static typing for example. For trivial-to-small code samples, static typing is completely useless cruft. In LARGE (man-month or 3 with multiple developers), it's definitely useful. This is somewhat hard to explain in a screencast.

I've gone toe to toe with Slava Pestov of Factor recently regarding a JSON parser and a basic non-blocking I/O webserver, both from scratch, and factor code was smaller than java code by a factor of 90%. In other words, where I had 10k LOC, he had 9k LOC. That's a virtual wash in my book, and nothing like the usual numbers claimed.

It also depends on programming style. I find this perfectly acceptable java:

someContainer.add(title = new Label("Title Goes Here"));

whereas most java programmers would rip this up into two lines. This goes into the meaning of a 'line of code'. A massive perl one-liner clearly is much more heavy than something like "a = 5". Almost all java vs. other code contests I've seen, the relative weight of each java line is on average way less. Just because a language likes to use a lot of punctuation doesn't mean it's inferior.

I'm not apologizing for java - in fact there are tons of changes I'd like to see. I'm just saying that trivial examples and pointless comparisons (LOC comparisons without any form of context or attempt to normalize vs. statement complexity) aren't convincing.
You know, if they started with 70 and eliminated all but three or four of them reality-show style, I would be totally sold on it. Now that's something one of these YC clones should try.
That's great. He should work up a hack on the gravity sensors so you can scroll web pages with inertia -- you give your iPhone a single quick shake and Safari goes down a page or so. Perfect for reading web pages while holding a subway strap, umbrella, dog leash, etc.
People often repeat web searches
The advice of having one point per slide and using an image instead of lots of text should be in a message that pops up everytime someone starts Powerpoint.
Andrew Chen: Facebook apps are the next generation of UGC
def birthday(people=23): from random import randint as rand; return sum([len(set([rand(1,365) for x in range(people)])) != people for i in range(1000)])

(constructs fewer inner lists, otherwise changes are completely cosmetic)
OK, I stand corrected. Statically-typed minds also frown on this. It might be only Lispers that feel differently (after all, they've been conflating an empty list, a boolean false, and a symbol NIL and insisting it's the right thing).
ah yes indeed much better! I tried to follow the K structure too much, but your code is too readable :D
I did and I still have trouble grasping it lol.
A List Apart: Design Choices Can Cripple a Website
Wrong On Hyperlocal: Google And Web 1.0 Killed Backfence
The strongest accusation I can find in this article is that: "it still isn't fool proof".

To what degree do 'real applications' have to be fool proof?

@joshwa: Thanks for point out the comments--I'm glad I read them, particularly this portion:

And even if the server software were to blow a gasket and call it quits w/o any warning and w/o rebooting itself, and from a more realistic viewpoint, even if the hardware were to fail, that still leaves the remaining slave servers who are at least within a handful of bytes of being accurate at the point the master server (if, in fact, it was the master server that gave up the ghost) called it quits. In this regard I fail to see a "this isn't capable of handling real-world applications" and instead "it's possible that something bad could happen, so prepare for the worst yet hope for the best and know that, within reason, it's far more likely that the best scenario (i.e. your data layer remains persistent as it should) will be what actually takes place 99.9999999999% of the time.

Yeah, so as someone using EC2 + S3 for our web enterprise, I am not really worried.
I am beyond screwed.
"keep their size under the memory allocated to postgres."

Assuming that you can do that, explain to me how this doesn't totally wipe away any scalability/performance advantage gained by using slow sql databases.

Well, yes, I guess it depends what you're doing. A speed increase of ~100x and increased simplicity made the crucial difference in my decision to drop the database for most of its traditional uses in my app.
Google and Yahoo working on next generation social networks
Ok these are out the door. I have a few more here if anybody would like them.
You're right, there's no support for OPML at all.

There's a new design in the works for adding feeds, different from what's there now, but I hadn't thought of using OPML until you mentioned it.

I'll post it in the next few days, so check back later in the week if you get a chance.

Alternatively, if you have any other feedback, let me know here, or just email me (my address is in my profile).
What I find more important now in retrospect is to agree upon a name as one of the first things when working together with someone. Not because the name is important, but because this will be the first decision where you can find out how good you will work together when you have an argument. If you can't decide on a name, work with someone else.
Why you won't run out of money
Your third and fourth sentences contradict one another. Unless your "mission" was to get busted for using sockpuppet accounts.
This is a good point. We find it also works as a predictor of success at the level of whole startups. When a group is spending half their time agonizing over what to call themselves, that's probably a sign of deeper breakage.
Justin.tv vs God
Check out the discussion linked to in the blog post comment as well.
Google to buy Postini for $625 million (100,000 businesses using Google Apps to date)
Point 3 about vocal variety is not as easy to do as you might think. You need practice. Toastmasters is a great organization for learning to speak well in front of groups, prepared or extemporaneous.

My club meets in Boston near Downtown Crossing on second and fourth Wednesdays at noon. Or look on the Toastmasters International web site (http://www.toastmasters.org/) for a club near you.

http://ourdoings.com/oratory-authority/
Wikipedia remains go-to site for online news (46.8 million uniques/month, up 72% from 2006)
> "mission accomplished... mission accomplished."

is that you, Mr. Prez? :~)
The takeaway? Build up to something unexpected in your presentations.

That's the only takeaway?

Jobs appeals to nostalgia and positions Apple as the heroic company making the world a better place for people to live in. It's emotional and genuine if perhaps a little exaggerated. That it builds up with dramatic tension is just the basic foundation of the speech. It's the details and romanticism that put it over the top.
Dynamic CSS Tabs in Symfony
This solution is based on the Sliding Door technique with dynamic width and a rollover effect. The menu is defined using a plain HTML list and using CSS you get a gracefully degradable tabbed menu. PHP is used to automate most of the process so that maintenance is very easy. Easily adaptable to other frameworks.
Google Blog: Welcome, Postini team
There's an explanation at the end that it means "Know your users." Was that explanation there when you read it?
You might want to google "Panopticon"
Mosh, Yahoo's New Social Network Initiative
They're Beautiful: virtual flowers from Jackson Fish Market
Why is NYC not more of a startup hub?

I think it comes down to two things: I-banks and hedge funds pay too well for most programmers to consider leaving those jobs to go the startup route.

And perhaps more importantly: there's not a strong tradition of successful founders who stay here as angel investors, unlike in Silicon Valley.
It could just as easily encourage the opposite behavior. People frequently do stupid things when they're trying to impress others.
Their parents, grandparents, boss, teachers, perhaps even their priest/rabbi, are watching!
On a related note:

http://ambient.media.mit.edu/assets/_pubs/what-woult-they-th...
I don't really understand your comment, but I'll just try to just restate more clearly and then maybe it will answer it anyway. If anyone has a specific situation, I'd be happy to speculate on it.

By keeping the indexes under the memory allocated to postgres, I mean the total memory that can be set aside to the DB on the machine. If you look at the pg data files you will find the indexes are just large flat files like BerkeleyDB or whatever homegrown file system thing you want to create.

So you do not need to increase the shared buffers to some crazy amount. In fact, you will have a negative performance result if you do that. The kernel will automatically cache these files upon repeated use. So if you have a machine with 4GB of memory and you can allocate 3GB to the db, then these indexes will just remain cached in memory forever. And you can easily get relatively cheap machines now with 16GB and higher, so this gets you really far.

If you only run sql queries that are indexed appropriately and the indexes are in memory, then I assure you postgres will not be the bottleneck in your app. This is not hard to do; it just takes a little postgresql.conf tweaking and data model forethought. In particular, you turn of sequential scans and decrease the index tuple cost and run select explain on all your queries to ensure that the indexes are always being used. As for the data model, use the smallest data types for indexes, and numeric types whenever possible. That will keep the size down to a minimum. PostgreSQL takes care of the rest.

Again, it depends on what you are doing, but this configuration will usually tie or be significantly better than some home grown file system thing when you get some scale because, like I said, postgres primarily uses the file system memory cache as its memory cache. But if you have some file system process that is accessing a ton of different files you will get an I/O bottleneck just from the lookups alone. And if you use a big flat file, you might as well stick with postgres because of its reliability, security, concurrency, network and backup features.

That being said, I still wouldn't store big static blobs in the db. I would just put them on another machine and let apache serve them up statically and put references to them in the db (indexed by some number id). That way you get the best of both worlds.
LFMs and LFSPs (Michael Vanier via PG)
A recent post by PG re: Arc spurred me to Google the term LFSP. Surprise, surprise, PG has an article on it on his own site.
I actually think I'd enjoy watching the lifecast of an anonymous criminal... not sure how they'd get around someone finding them but if they did I'd be there. It might be possible when they get the camera size down but not right now.

some people really dont care and i would want to watch that guy hah!
What's the deal with BizDev?
No disrespect intended, but BizDev people are really just sales people with a very small prospect base, and usually high quota numbers. They are chasing the big deals. There are few constraints put on them, because the relationships are strategic, and so this pattern of cozying up to large vendors, bending over backwards to impress them, only to usually have the rug pulled out later happens again and again.
I think Joe Average and Joe Boss's perceptions of the advantages of LFMs are completely bogus. The same solution implemented in an LFM and an LFSP will be more readable in the LFSP.
To get wider use of LFSPs, it would be important for more people to learn that you can and it's completely reasonable to interface several programming languages. You need to be comfortable with both languages to work on the interface, but I find it surprising we didn't practice this at school at all.

To explicate what the article touches: Perhaps you really have to use Java because of platform or workforce requirements, but it doesn't mean you have to use 100% Java. More experienced developers can build some of the low-level classes using C++ via JNI. They can also set up BeanShell or Jython for user interface and test scripters.
One of the features of LFSP's is that the code density is higher, which I'd argue is a good way to make the code harder to read, not easier.

Here's an example in ruby:

(1...10).each{ |x| print x }

Tell me, does the 10 print or not? You'll need a second glance plus a good memory to answer that question.

Here's the same code in C++:

for (int x = 1; x < 10; x++)
cout << x;

Verbosity makes it easier for the non-you programmer to look at a random piece of code and decipher it. You feel smarter for having written that Ruby code (and the C++ is boring, I'll agree). But I'm gonna have to say the Ruby code has less readability outright just because it's so dense.
Where to best track positioning in search engines (by keyword)?
The only reason I can think of why someone would look at the Ruby code and not be immediately sure that the 10 prints, is if they've become very accustomed to for loops like the one in the C++ example. It's conditioning, not intelligence, that makes the difference.
Passive-Aggressive Behavior Is Useless In A Startup
I think you missed part of my point, which is that "..." vs. ".." is a subtlety introduced by the mantra of high-density syntax seen in LFSP design.

The 10 doesn't print, btw.
Unfortunately, interfacing multiple languages is itself not a strategy for LFM-people, because most of them can (or believe they can) only fit one language into their brains. There are costs to using more than one language on a project. Managers frequently overestimate these costs, because they're the ones who will look bad if their superior (or investor) looks at their development process and say "Wow, this is chaos. No wonder you can't ship software."

There does seem to be a loophole: you can use multiple languages if they all start with the same buzzword. So, the same manager who balks at a Python/C++/SQL solution because it uses too many languages has no problem requiring that his developers learn Java, JavaScript, Java Server Faces, Java Persistence Query Language, Java Expression Language, and the Java Standard Tag Library, because they all start with "Java". Same goes with XML/XSLT/XSLFO/XPath and derivatives.

Based on this observation, I suggest a renaming of all common hacker tools. Python should be renamed "ParrotSnake", Ruby "ParrotGems", Lisp "ParrotParens", SQL "ParrotQueries", JavaScript "Parrot in a Browser", HTML "ParrotTags", Haskell "ParrotMonads", and so on. Then we could freely use any of these on a project, because they're all the same language, duh. Of course, the Parrot project itself should be canceled, because it'd defeat the purpose to have them actually running on a common VM. This is strictly a marketing initiative.
The bizdev strategy he points to has always confused me in it's logic. Maybe I'm too conservative, maybe going for the big vender is sales diversification. What would the math look like re costs vs. returns over 2 years w/a team of 4, and with the IBM like vender buy out?
Ruby and C++ both have a complex syntax, nevermind that being superficial. The LFSP example in the article was Ocaml, which doesn't even have operator overloading! What makes Ocaml an LFSP - the little I know about it - includes a nice combination of FP and OO plus a powerful type system.
Insightful! But does this in your opinion apply only to LFM-people - my understanding is most LFSP-people don't see multiple languages as an option either?
Shawn, thanks for your detailed feedback, we believe you're dead on about the points you discussed. We're making changes now. Thanks again - Jamal.
Any chances for recreating this in a telecommuting way? I would have loved to attend, but crossing the Atlantic seemed too far (although now I almost regret that I didn't go anyway).

Maybe a 48 hour startup competition would do, too? Not working on a startup together, but everybody on their own startup? I participated in the 48h game programming competition once, and it was a lot of fun. People would just exchange advice and ideas in irc while the event was on, and it was a great sense of community.
Thanks for sharing, been there done that. ;-D
I dunno - most LFSP-people I know use multiple languages regularly, learn new ones as a hobby, and their "preferred" LFSP is just the top of a long list of skills. That's why we call them "smart people". ;-) Take a look at Programming Reddit - most of the Haskell evangelists are also quite fluent in Python and C and usually know Lisp, Ocaml, etc. too.

There do seem to be exceptions - Common Lisp in particular seems to be a LFSP where many of its leading practitioners only know Lisp. Smalltalk, too, but to a lesser extent since all the commercial Smalltalk jobs morphed into Objective C or Java jobs. But I don't really see Lisp as being at the top of the blub hierarchy any more - there's been 20 years of progress since then and some really interesting developments.
I'd forgotten how well written that was. It's better than 99% of the essays on the web. And yet it was just an ordinary email, not intended for publication.
Actually Vanier may have a point that LFMs make programmers more interchangeable at big cos. So ultimately the argument against them may be startups.
I'm a game developer. At work, we use C++, C# and our own scripting language. Our language is embedded, so the communication protocols between C++ <-> our language are straightforward, and C++ <-> C# happens through function callbacks.

At home, I use C++ plus Lua. I tried to use Lisp, but the CFFI had problems interfacing with certain foreign libraries.

To get around C++'s constraints, my solution is to move all of my game engine code to Lua with only a lightweight wrapper in C++. Lua is extremely powerful - for example, functions are first class objects, so it has closures. It's dynamically typed, so I'll spend less time convincing a compiler I should be able to run my code. It's very fast, because it has a JIT compiler which uses DynASM to generate assembly code, so it's about 1/10th the speed of C - huge for a scripting language. But most importantly, the communication protocols between Lua and C are extremely clearly defined, and work. Communication between Lisp and C is much more vague, and only sometimes works - Calling Lisp from C, for example, don't work on all platforms.

So I'd guess what influences me in my choice of multiple languages is how well two languages can communicate with one another. Can all constructs from Blub translate into Floob? How does Blub call into Floob, and vice-versa? Is it supported on all platforms? Is there a lot of example code?

You can certainly have a language mashup and solve problems in elegant ways, but it all hinges on how elegant the communication is.

If you use several different languages, and if they don't share resources (Window handles and such), and if communication between them is not speed-critical, then you can write a networking layer which each language uses to communicate with every other language. But that option seems pretty rare.

Shawn
You sure did mix metaphors. If the "entrepreneurs" are living 10 to an apartment and eating ramen, why would they be driving a Prius?

Some people just get off on being contrarian.
Corporate vs. Startup behaviors
I don't think the ".." vs "..." level of density is universal in LFSP design. Macros in Lisp/Scheme are words. See the sql-repeat macro with group-beginning? and group-ending? for example. It makes things more transparent than your typical LFM implementation would:

http://brl.codesimply.net/brl_4.html#SEC31
While getting a $25000 college graduation present would be fantastic (although I bet she just bought a car), your projection is a bit optimistic. While yes, she would have a million dollars, that million dollars would only be worth $295712 after accounting for inflation (at a constant 3% yearly.) Still great, but she's not exactly ready for retirement.
I work in a Java shop but do some statistical work using R. For me, Java is the easiest way to gather together data for an analysis. R is the clear winner over Java for doing statistical modeling. Gluing them together is possible, and some people have written bindings. However, these are not well documented, and they are not mature enough to use in a production environment. The difference when mixing together use of (J/X)* languages is that they have mature bindings (often simply because they are all written in Java).

I'm all for using the right tool for the job, but it's really hard to take on the risk of an integration one might have to maintain or expand upon. Using two languages isn't itself a problem, either for developers or managers.
I'm not so sure. Most of the Common Lisp people I've met know Java. I can't think of a single one who doesn't know C.

Or did you mean Common Lisp people tend to have only that language as their LFSP, no matter how many LFMs they know? In that case I would agree - I definitely see CLers ignoring Ocaml, smalltalk, etc. For my part I guess it's because CL took a long time to learn fully and I need to build up some energy before I invest that amount of time in another LFSP.
If programming languages were cars...
If (1...10) doesn't yield a list of numbers from 1 to 10 inclusive, that's a bug in Ruby. The problem is not density. It's perfectly clear what this code example should mean.
Alternatives to VC funding
I'm not claiming that that example is dense code in and of itself, merely that encoding important differences in subtle ways is a by product of the LSFP way of thought. Verbose code is the opposite of clever code, so far as I can see.
Does this still happen?
I agree, the for loop is not intuitive at all, just historically present. However, try comparing the ruby against:

for x in range(10):
print x
Having a language that is massively popular is one factor in making it easier to find someone to take over code, but I think many managers have an unrealistic estimate of how much it helps. In some ways it actually hinders, by putting more noise into the hiring process.

In my day job, the ultimate argument was hiring a new graduate who was writing good production code in the LFSP on his second day. An LFSP lets you create a language that fits the problem domain nicely. This works both in normal companies and in startups.

If you're saying that startups can prove the value of an LFSP by being successful with it, I agree. If you're saying that doing a project as a startup eliminates the risk of having code that is hard for someone else to maintain, then I disagree. There are plenty of reasons why a startup might need to find someone capable of working within their codebase.
When To Dump That Great Idea