id
int64 2
42.1M
| by
large_stringlengths 2
15
⌀ | time
timestamp[us] | title
large_stringlengths 0
198
⌀ | text
large_stringlengths 0
27.4k
⌀ | url
large_stringlengths 0
6.6k
⌀ | score
int64 -1
6.02k
⌀ | descendants
int64 -1
7.29k
⌀ | kids
large list | deleted
large list | dead
bool 1
class | scraping_error
large_stringclasses 25
values | scraped_title
large_stringlengths 1
59.3k
⌀ | scraped_published_at
large_stringlengths 4
66
⌀ | scraped_byline
large_stringlengths 1
757
⌀ | scraped_body
large_stringlengths 1
50k
⌀ | scraped_at
timestamp[us] | scraped_language
large_stringclasses 58
values | split
large_stringclasses 1
value |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
62,750 | jkush | 2007-10-03T20:06:52 | .NET framework source code to be released | http://weblogs.asp.net/scottgu/archive/2007/10/03/releasing-the-source-code-for-the-net-framework-libraries.aspx | 17 | 12 | [
62778,
62844,
62780,
62899,
63182
] | null | null | null | null | null | null | null | null | null | train |
|
62,753 | garbowza | 2007-10-03T20:15:42 | Microsoft focusing on software in battle against iPod | http://www.nytimes.com/2007/10/03/technology/03zune.html | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,754 | nickb | 2007-10-03T20:19:42 | Practical Image Recognition (prevents cat entering house when she carries a mouse) | http://www.quantumpicture.com/Flo_Control/flo_control.htm | 24 | 2 | [
62865,
62894
] | null | null | null | null | null | null | null | null | null | train |
|
62,758 | nickb | 2007-10-03T20:27:45 | JavaScript: Put everything in a namespace | null | http://www.lixo.org/archives/2007/09/14/javascript-put-everything-in-a-namespace/ | 1 | 1 | [
62791
] | null | null | null | null | null | null | null | null | null | train |
62,759 | nickb | 2007-10-03T20:28:16 | Making Ajax Elegantly Fast | null | http://www.dustindiaz.com/faster-ajax/ | 9 | 0 | null | null | null | null | null | null | null | null | null | null | train |
62,762 | SwellJoe | 2007-10-03T20:33:44 | The sometimes precarious business models for Open Source software | http://inthebox.webmin.com/open-source-and-business-a-precarious-partnership | 7 | 2 | [
62946
] | null | null | null | null | null | null | null | null | null | train |
|
62,767 | igexome | 2007-10-03T20:45:10 | Ask YC: User feedback? | I'm wrapping up my last year of school and plan on applying for the summer YC program with two friends to work on a project we're experimenting with now. One of the key elements that I proposed was having an absolute seamless user feedback system.<p>I spent the past six months as an intern at a company that practiced a mix of scrum and XP methodologies and learned how important getting feedback is for the success and direction of a product, so I'm asking every bright person here for any examples or ideas in integrating in a feedback system for a web application. I like twitter.com's system [<a href="http://twitter.com/help" rel="nofollow">http://twitter.com/help</a>], but that is simply to request to get help. What about a way of allowing for user suggestions? My only concern is that it could easily be "overdone" and draw away from a clean and usable site. | 2 | 4 | [
62786,
62835
] | null | null | invalid_url | null | null | null | null | 2024-11-08T16:37:59 | null | train |
|
62,768 | niels | 2007-10-03T20:45:52 | Testing Django applications | New documentation for testing django apps. I especially like the test client you can use to simulate http requests with. | http://www.djangoproject.com/documentation/testing/ | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
62,772 | raithe | 2007-10-03T20:58:51 | WordHugger allows internet marketers to own a piece of the web. | null | http://www.centernetworks.com/wordhugger-launches | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
62,774 | drm237 | 2007-10-03T21:00:21 | TechCrunch And Huffington: Who Will Buy The Big Blogs? | The name brand blogs. The big ones. Huffington. TechCrunch. GigaOm. Boing Boing. Ars Technica. SeekingAlpha.<p>AOL has already bought Weblogsinc. It owns popular blogs including flagship Engadget.<p>But, with the internet operations at newspapers and some other tradition media companies making very little headway, the big blogs take on a very significant attraction. They reach audiences in great numbers. They have credibility. They are not expensive to run. And, they make money. | http://www.247wallst.com/2007/10/techcrunch-and-.html | 1 | 1 | [
62777
] | null | null | no_article | null | null | null | null | 2024-11-08T07:48:45 | null | train |
62,783 | rms | 2007-10-03T21:28:45 | A nice feel-good futurist article from the president of the Italian Space Agency | http://www.iht.com/articles/2007/10/03/news/edsputnik.php | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,787 | scrollinondubs | 2007-10-03T21:35:03 | Y Combinator co-founder Jessica Livingston shares advice on how to get accepted (audio interview) | http://www.grid7.com/archives/189_podcast-28-jessica-livingston-of-y-combinator.html | 52 | 14 | [
62818,
62850,
62825,
62820,
63020
] | null | null | null | null | null | null | null | null | null | train |
|
62,800 | joshwa | 2007-10-03T22:05:32 | Inside Amazon's dynamo - the Distributed Storage System *behind* S3 | null | http://www.roughtype.com/archives/2007/10/inside_amazons.php | 3 | 1 | [
62855
] | null | null | null | null | null | null | null | null | null | train |
62,802 | transburgh | 2007-10-03T22:13:47 | Broadcast your miserable life with Justin.tv | null | http://valleywag.com/tech/lifecasters/broadcast-your-miserable-life-with-justintv-306800.php | 2 | 1 | [
62808
] | null | null | null | null | null | null | null | null | null | train |
62,811 | brett | 2007-10-03T22:50:02 | The Pmarca Guide to Career Planning, Part 3: Where to go and why | null | http://blog.pmarca.com/2007/10/the-pmarca-gu-1.html | 33 | 20 | [
62908,
62859,
63081,
62950,
62879
] | null | null | null | null | null | null | null | null | null | train |
62,824 | bootload | 2007-10-03T23:19:54 | Spying on competitors | http://www.cioupdate.com/trends/article.php/3521996 | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,829 | unfoldedorigami | 2007-10-03T23:23:49 | Visualizing Fitts's Law | null | http://particletree.com/features/visualizing-fittss-law/ | 22 | 0 | null | null | null | null | null | null | null | null | null | null | train |
62,830 | bootload | 2007-10-03T23:24:15 | Coms vital when there's an outage | http://www.scripting.com/stories/2007/10/03/communicationIsVitalWhenTh.html | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,832 | bootload | 2007-10-03T23:27:14 | What is Google doing? | http://www.scripting.com/stories/2007/10/02/whatIsGoogleDoing.html | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,836 | bootload | 2007-10-03T23:40:49 | Interview with danah boyd | http://www.oreillynet.com/pub/a/womenintech/2007/09/07/interview-with-danah-boyd.html | 1 | 0 | null | null | null | no_error | O'Reilly Media - Technology and Business Training | null | null |
New! O’Reilly announces launch of the AI Academy. Read nowIntroducing the AI Academy Help your entire org put GenAI to work
Every employee today needs to know how to prompt GenAI, use it to enhance critical thinking and productivity, and more. With the AI Academy they can. For less.
O’Reilly AI-powered Answers just got even smarter
O’Reilly Answers instantly generates information teams can trust, sourced from thousands of titles on our learning platform.
Discover Answers
Give your teams the GenAI and tech skills they need
More than 5,000 organizations count on our learning platform and AI Academy to help their teams learn the tools and technologies that drive business outcomes. We can help yours too.
Hear why Jose is on O’Reilly every day
Jose, a principal software engineer, trusts our learning platform to filter what his teams need to know to stay ahead.
See why Addison loves our learning platform
Addison always appreciated O’Reilly books, but the learning platform helped take her skills to the next level.
Amir trusts O’Reilly to find the answers he needs. See why.
For over eight years Amir has counted on our learning platform whether he needs proven methods to learn new technologies or the latest management tips.
Mark’s been an O’Reilly member for 13 years. See why.
Mark credits the O’Reilly learning platform with helping him to stay ahead at every turn throughout his tech career.
See more testimonials
The 2024 O’Reilly Awards winners are in!
Learn who best put the O’Reilly learning platform to work for their organization and what the judges were looking for in winning submissions.
Get the results
O’Reilly Experts
Sharing the knowledge of innovators for over 40 years
From books to leading tech conferences to a groundbreaking online learning platform, we’ve focused on creating the best technical learning content for more than four decades. Your teams can benefit from that experience.
Keep your organization ahead of what’s next
Live events
Get in the virtual room with an expert instructor who’ll take questions and guide you through today’s most important tools and technologies.
Learn from experts
Interactive labs
Get step-by-step guidance in a secure coding environment to learn fundamental concepts, practice a use case, prepare for a certification, or explore a new tool.
Hands-on learning
Courses
Pick the role you have (or the role you want) and we’ll guide you to the top live and on-demand courses to learn the technologies and skills you need to succeed.
Explore courses
Certifications
A certification means you can trust they’ve mastered the skills your organization needs. We help your people prep for their exams with direct paths to the official materials and interactive practice tests.
Get them certified
5,000+ courses to keep teams on the right path
Our live and on-demand courses are organized by skill and role, and team members get verifiable and sharable badges that use the Open Badges 2.0 standard to show off what they’ve learned.
Explore courses
Live events keep your organization ahead of what’s next
Your teams have access to nearly 1,000 live online courses and events every year, led by top experts in AI, software architecture, cloud, data, programming, and more. And they can ask questions along the way.
Kai Holnes, Thoughtworks
Learn from experts
Certified teams are teams you can count on
Trust that they’ve mastered the skills your organization needs. Help your people prep for their certification exams with direct paths to the official materials and interactive practice tests.
Get them certified
See how O’Reilly can help your tech teams stay ahead
| 2024-11-08T20:55:09 | en | train |
|
62,839 | transburgh | 2007-10-03T23:46:45 | Google Purges The Payola | null | http://www.forbes.com/technology/2007/10/02/internet-paid-search-tech-cx_ag_1003google.html?feed=rss_technology | 4 | 0 | null | null | null | null | null | null | null | null | null | null | train |
62,840 | pg | 2007-10-03T23:53:36 | Laptop With a Mission Widens Its Audience | null | http://www.nytimes.com/2007/10/04/technology/circuits/04pogue.html?ex=1349150400&en=12d8a1ff28c4df27&ei=5090&partner=rssuserland&emc=rss | 4 | 1 | [
65730
] | null | null | null | null | null | null | null | null | null | train |
62,842 | nickb | 2007-10-03T23:59:24 | MIT's DARPA Urban Challenge entry powered by 10 quad-core computers | null | http://www.technologyreview.com/Infotech/19471/ | 1 | 0 | null | null | null | http_404 | 404 - Page not found | null | null | The latest iteration of a legacyFounded at the Massachusetts Institute of Technology in 1899, MIT Technology Review is a world-renowned, independent media company whose insight, analysis, reviews, interviews and live events explain the newest technologies and their commercial, social and political impact.Advertise with MIT Technology ReviewElevate your brand to the forefront of conversation around emerging technologies that are radically transforming business. From event sponsorships to custom content to visually arresting video storytelling, advertising with MIT Technology Review creates opportunities for your brand to resonate with an unmatched audience of technology and business elite. | 2024-11-07T07:21:11 | null | train |
62,846 | nickb | 2007-10-04T00:42:55 | Tools of The Effective Developer: Fail Fast! | null | http://www.hans-eric.com/2007/10/02/tools-of-the-effective-developer-fail-fast/ | 3 | 0 | null | null | null | null | null | null | null | null | null | null | train |
62,848 | cant_login_juwo | 2007-10-04T00:47:56 | Ask YC: cannot login. how to reset password? | Cannot login as juwo. Getting a login prompt now - earlier it used to save my password. Didnt delete any cookies. My password does not work, nor can I reset it.<p>Sent email but there was no reply.<p>Anyone have/had the same problem? | 2 | 0 | null | null | null | invalid_url | null | null | null | null | 2024-11-08T16:37:59 | null | train |
|
62,849 | myoung8 | 2007-10-04T00:49:26 | An Observation about News.YC | In too many threads on news.yc someone points out a pattern only to have someone else refute it based on perosnal experiences. <p>I just want to point out that this is flawed logic!<p>It's not quite as simple as "don't make generalizations" (although many would do well to remember that). Danah boyd really crystallized this in one of her blog posts by pointing out that
patterns are just that, patterns. There will always be exceptions (and maybe you are one of them), but exceptions and patterns are not mutually exclusive. Duh, right?<p>If it's so obvious, why do so many people craft their arguments this way? Just check out the comments in the post about how to find a co-founder for non-techies.<p>Maybe they just want to foster discussion, but it seems to me that we would get a lot more out of the forum if people qualified/quantified their comments. | 7 | 6 | [
62875,
62867,
62983,
63091,
63022,
62973
] | null | null | invalid_url | null | null | null | null | 2024-11-08T16:37:59 | null | train |
|
62,863 | ivankirigin | 2007-10-04T01:19:49 | ARM spins multicore-enabled Cortex core. Translation: multi-core cellphones. | null | http://www.linuxdevices.com/news/NS2917028234.html | 2 | 0 | null | null | null | missing_parsing | [200+] Linux Wallpapers | Wallpapers.com | null | null |
Wallpapers
Linux Wallpapers
(300+ Linux Wallpapers)
Spice up your device with unique Linux wallpapers that showcase your love for open-source software. Choose from a variety of designs that will make your screen stand out.
Linux Wallpapers
| 2024-11-08T17:43:35 | null | train |
62,870 | dood | 2007-10-04T01:41:25 | Why Programmers suck at Picking Colors | http://www.betaversion.org/~stefano/linotype/news/108/ | 25 | 15 | [
63249,
62934,
62906,
62977,
62918,
63584,
63063,
63120,
62981
] | null | null | null | null | null | null | null | null | null | train |
|
62,876 | nickb | 2007-10-04T02:13:33 | Club Penguin: Did Disney buy a $350 million dud? (another fad) | null | http://valleywag.com/tech/club-penguin/did-disney-buy-a-350-million-dud-306841.php | 2 | 0 | null | null | null | fetch failed | null | null | null | null | 2024-11-08T04:36:38 | null | train |
62,882 | nickb | 2007-10-04T02:48:34 | A Brief History of Slashdot Part 1, Chips & Dips | null | http://meta.slashdot.org/meta/07/10/02/1553218.shtml | 4 | 0 | null | null | null | null | null | null | null | null | null | null | train |
62,883 | nickb | 2007-10-04T02:50:43 | Three blog posts I'd love to read (and one that I wouldn't) | null | http://weblog.raganwald.com/2007/10/three-blog-posts-id-love-to-read-and.html | 7 | 0 | null | null | null | null | null | null | null | null | null | null | train |
62,884 | nickb | 2007-10-04T02:52:04 | Subversion's Delta Editor: Interface As Ontology | null | http://www.red-bean.com/kfogel/beautiful-code/bc-chapter-02.html | 2 | 0 | null | null | null | missing_parsing | Beautiful Code | null | null | Chapter�2.�Subversion's Delta Editor: Interface As OntologyKarl Fogel
Examples of beautiful code tend to be local solutions to
well-bounded, easily comprehensible problems, such
as Duff's Device
(http://en.wikipedia.org/wiki/Duff's_device)
or rsync's rolling checksum algorithm
(http://en.wikipedia.org/wiki/Rsync#Algorithm). This is
not because small, simple solutions are the only beautiful kind, but
because appreciating complex code requires more context than can be
given on the back of a napkin.Here, with the luxury of several pages to work in, I'd like to
talk about a larger sort of beauty�—�not necessarily the kind
that would strike a passing reader immediately, but the kind that
programmers who work with the code on a regular basis would come to
appreciate as they accumulate experience with the problem domain. My
example is not an algorithm, but an interface: the programming
interface used by the open source version control system Subversion
(http://subversion.tigris.org) to express the
difference between two directory trees, which is also the interface
used to transform one tree into the other. In Subversion, its formal
name is the C
type svn_delta_editor_t, but it is
known colloquially as the delta editor.Subversion's delta editor demonstrates the
properties that programmers look for in good design. It breaks down
the problem along boundaries so natural that anyone designing a new
feature for Subversion can easily tell when to call each function, and
for what purpose. It presents the programmer with uncontrived
opportunities to maximize efficiency (such as by eliminating
unnecessary data transfers over the network) and allows for easy
integration of auxiliary tasks (such as progress reporting). Perhaps
most important, the design has proved very resilient during
enhancements and updates.And as if to confirm suspicions about the origins of good
design, the delta editor was created by a single person over the
course of a few hours (although that person was very familiar with the
problem and the code base).To understand what makes the delta editor beautiful, we must
start by examining the problem it solves.Version Control and Tree TransformationVery early in the Subversion project, the team realized we had a
general task that would be performed over and over: that of minimally
expressing the difference between two similar (usually related)
directory trees. As a version control system, one of Subversion's
goals is to track revisions to directory structures as well as
individual file contents. In fact, Subversion's server-side repository
is fundamentally designed around directory versioning. A repository is
simply a series of snapshots of a directory tree as that tree
transforms over time. For each changeset committed to the repository,
a new tree is created, differing from the preceding tree exactly where
the changes are located and nowhere else. The unchanged portions of
the new tree share storage with the preceding tree, and so on back
into time. Each successive version of the tree is labeled with a
monotonically increasing integer; this unique identifier is called
a revision number.Think of the repository as an array of revision numbers,
stretching off into infinity. By convention, revision 0 is always an
empty directory. In the example below, revision 1 has a tree hanging
off it (typically the initial import of content into the repository),
and no other revisions have been committed yet. The boxes represent
nodes in this virtual filesystem: each node is either a directory
(labeled DIR in the upper-left corner) or a file (labeled
FILE):Figure�2-1.�Conceptual view of revision numbersWhat happens when we modify tuna? First, we
make a new file node, containing the latest text. The new node is not
connected to anything yet, it's just hanging out there in space, with
no name:Figure�2-2.�New node when just createdNext, we create a new revision of its parent directory. The
subgraph is still not connected to the revision array:Figure�2-3.�Creation of new parent directoryWe continue up the line, creating a new revision of the next
parent directory:Figure�2-4.�Continuing to move up, creating parent directoriesAt the top, we create a new revision of the root
directory. This new directory needs an
entry to point to the "new" directory A, but since directory B hasn't
changed at all, the new root directory also has an entry still
pointing to the old directory B's node:Figure�2-5.�Complete new directory treeNow that all the new nodes are written, we finish the "bubble
up" process by linking the new tree to the next available revision in
the history array, thus making it visible to repository users. In this
case, the new tree becomes revision 2:Figure�2-6.�Finished revision: link to new treeThus each revision in the repository points to the root node of
a unique tree, and the difference between that tree and the preceding
one is the change that was committed in the new revision. To trace the
changes, a program walks down both trees simultaneously, noting where
entries point to different places. (For brevity, I've left out some
details, such as saving storage space by compressing older nodes as
differences against their newer versions.)Although this tree-versioning model is all
background to the main point of this chapter
(the delta editor, which we'll come to
soon), it has such nice properties that I considered making it the
subject of its own chapter, as an example of beautiful code. Some of
its attractive features are:Easy readsTo locate revision n of
file /path/to/foo.txt, one jumps to
revision n, then walks down the tree
to /path/to/foo.txt.Writers don't interfere with readersAs writers create new nodes, bubbling their way up to the
top, concurrent readers cannot see the work in progress. A new
tree becomes visible to readers only after the writer makes its
final "link" to a revision number in the repository.Tree structure is versionedThe very structure of each tree is being saved from
revision to revision. File and directory renames, additions, and
deletions become an intrinsic part of the repository's
history.If Subversion
were only a repository, this would be the end of the story. However,
there's a client side, too: the working copy,
which is a user's checked-out copy of some revision tree plus whatever
local edits the user has made but not yet committed. (Actually,
working copies do not always reflect a single revision tree; they
often contain mixtures of nodes from different revisions. This turns
out not to make much of a difference as far
as tree transformation is
concerned. So, for the purposes of this chapter, just assume that a
working copy represents some revision tree, though not necessarily
that of the latest revision.)Expressing Tree DifferencesThe most common action in Subversion
is to transmit changes between the two sides: from the repository to
the working copy when doing an update to receive others' changes, and
from the working copy to the repository when committing one's own
changes. Expressing the difference between two trees is also key to
many other common operations�—�e.g., diffing, switching to a
branch, merging changes from one branch to another, and so
on.Clearly it would be silly to have two different interfaces, one
for server→client and another for client→server. The
underlying task is the same in both cases. A tree difference is a tree
difference, regardless of which direction it's traveling over the
network or what its consumer intends to do with it. But finding a
natural way to express tree differences proved surprisingly
challenging. Complicating matters further, Subversion supports
multiple network protocols and multiple backend storage mechanisms; we
needed an interface that would look the same across all of
those.Our initial attempts to come up with an interface ranged from
unsatisfying to downright awkward. I won't describe them all here, but
what they had in common was that they tended to leave open questions
for which there were no persuasive answers.For example, many of the solutions involved transmitting the
changed paths as strings, either as full paths or path
components. Well, what order should the paths be transmitted in? Depth
first? Breadth first? Random order? Alphabetical? Should there be
different commands for directories than for files? Most importantly,
how would each individual command expressing a difference know that it
was part of a larger operation grouping all the changes into a unified
set? In Subversion, the concept of the overall tree operation is quite
user-visible, and if the programmatic interface didn't intrinsically
match that concept, we'd surely need to write lots of brittle glue
code to compensate.In frustration, I drove with another developer, Ben
Collins-Sussman, from Chicago down to Bloomington, Indiana, to seek
the advice of Jim Blandy, who
had invented Subversion's repository model in the first place, and who
has, shall we say, strong opinions about design. Jim listened quietly
as we described the various avenues we'd explored for transmitting
tree differences, his expression growing grimmer and grimmer as we
talked. When we reached the end of the list, he sat for a moment and
then politely asked us to scram for a while so he could think. I put
on my jogging shoes and went running; Ben stayed behind and read a
book in another room or something. So much for collaborative
development.After I returned from my run and showered, Ben and I went back
into Jim's den, and he showed us what he'd come up with. It is
essentially what's in Subversion today; there have been various
changes over the years, but none to its fundamental structure.The Delta Editor InterfaceFollowing is a mildly abridged version of the delta editor
interface. I've left out the parts that deal with copying and
renaming, the parts related to Subversion
properties (properties are versioned metadata, and are not important
here), and parts that handle some other Subversion-specific
bookkeeping. However, you can always see the latest version of the
delta editor by visiting
http://svn.collab.net/repos/svn/trunk/subversion/include/svn_delta.h. This
chapter is based on r21731 (that is, revision 21731) at
http://svn.collab.net/viewvc/svn/trunk/subversion/include/svn_delta.h?revision=21731.To understand the interface, even in its abridged form, you'll
need to know some Subversion jargon:poolsThe pool arguments are
memory pools�—�allocation buffers that allow a large number
of objects to be freed simultaneously.svn_error_tThe return
type svn_error_t simply means
that the function returns a pointer to a Subversion error object;
a successful call returns a null
pointer.text deltaA text delta is the difference between two different
versions of a file; you can apply a text delta as a patch to one
version of the file to produce the other version. In Subversion,
the "text" of a file is considered binary data�—�it doesn't
matter whether the file is plain text, audio data, an image, or
something else. Text deltas are expressed as streams of
fixed-sized windows, each window containing a chunk of binary
diff data. This way, peak memory usage is proportional to the
size of a single window, rather than to the total size of the
patch (which might be quite large in the case of, say, an image
file).window handlerThis is the function prototype for applying one window of
text-delta data to a target file.batonThis is a void * data
structure that provides context to a callback function. In other
APIs, these are sometimes called void
*ctx, void *userdata, or void
*closure. Subversion calls them "batons" because
they're passed around a lot, like batons in a relay
race.The interface starts with an introduction, to put a reader of
the code in the right frame of mind. This text is almost unchanged
since Jim Blandy
wrote it in August of 2000, so the general concept has clearly
weathered well: /** Traversing tree deltas.
*
* In Subversion, we've got various producers and consumers of tree
* deltas.
*
* In processing a `commit' command:
* - The client examines its working copy data, and produces a tree
* delta describing the changes to be committed.
* - The client networking library consumes that delta, and sends them
* across the wire as an equivalent series of network requests.
* - The server receives those requests and produces a tree delta --
* hopefully equivalent to the one the client produced above.
* - The Subversion server module consumes that delta and commits an
* appropriate transaction to the filesystem.
*
* In processing an `update' command, the process is reversed:
* - The Subversion server module talks to the filesystem and produces
* a tree delta describing the changes necessary to bring the
* client's working copy up to date.
* - The server consumes this delta, and assembles a reply
* representing the appropriate changes.
* - The client networking library receives that reply, and produces a
* tree delta --- hopefully equivalent to the one the Subversion
* server produced above.
* - The working copy library consumes that delta, and makes the
* appropriate changes to the working copy.
*
* The simplest approach would be to represent tree deltas using the
* obvious data structure. To do an update, the server would
* construct a delta structure, and the working copy library would
* apply that structure to the working copy; the network layer's job
* would simply be to get the structure across the net intact.
*
* However, we expect that these deltas will occasionally be too large
* to fit in a typical workstation's swap area. For example, in
* checking out a 200Mb source tree, the entire source tree is
* represented by a single tree delta. So it's important to handle
* deltas that are too large to fit in swap all at once.
*
* So instead of representing the tree delta explicitly, we define a
* standard way for a consumer to process each piece of a tree delta
* as soon as the producer creates it. The svn_delta_editor_t
* structure is a set of callback functions to be defined by a delta
* consumer, and invoked by a delta producer. Each invocation of a
* callback function describes a piece of the delta --- a file's
* contents changing, something being renamed, etc.
*/
Then comes a long, formal documentation comment, followed by
the interface
itself, which is a callback table whose invocation order is partially
constrained: /** A structure full of callback functions the delta source will invoke
* as it produces the delta.
*
* Function Usage
* ==============
*
* Here's how to use these functions to express a tree delta.
*
* The delta consumer implements the callback functions described in
* this structure, and the delta producer invokes them. So the
* caller (producer) is pushing tree delta data at the callee
* (consumer).
*
* At the start of traversal, the consumer provides edit_baton, a
* baton global to the entire delta edit.
*
* Next, if there are any tree deltas to express, the producer should
* pass the edit_baton to the open_root function, to get a baton
* representing root of the tree being edited.
*
* Most of the callbacks work in the obvious way:
*
* delete_entry
* add_file
* add_directory
* open_file
* open_directory
*
* Each of these takes a directory baton, indicating the directory
* in which the change takes place, and a path argument, giving the
* path (relative to the root of the edit) of the file,
* subdirectory, or directory entry to change. Editors will usually
* want to join this relative path with some base stored in the edit
* baton (e.g. a URL, a location in the OS filesystem).
*
* Since every call requires a parent directory baton, including
* add_directory and open_directory, where do we ever get our
* initial directory baton, to get things started? The open_root
* function returns a baton for the top directory of the change. In
* general, the producer needs to invoke the editor's open_root
* function before it can get anything of interest done.
*
* While open_root provides a directory baton for the root of
* the tree being changed, the add_directory and open_directory
* callbacks provide batons for other directories. Like the
* callbacks above, they take a parent_baton and a relative path
* path, and then return a new baton for the subdirectory being
* created / modified --- child_baton. The producer can then use
* child_baton to make further changes in that subdirectory.
*
* So, if we already have subdirectories named `foo' and `foo/bar',
* then the producer can create a new file named `foo/bar/baz.c' by
* calling:
*
* - open_root () --- yielding a baton root for the top directory
*
* - open_directory (root, "foo")
*
* - open_directory (f, "foo/bar") --- yielding a baton b for `foo/bar'
*
* - add_file (b, "foo/bar/baz.c")
*
* When the producer is finished making changes to a directory, it
* should call close_directory. This lets the consumer do any
* necessary cleanup, and free the baton's storage.
*
* The add_file and open_file callbacks each ret urn a baton
* for the file being created or changed. This baton can then be
* passed to apply_textdelta to change the file's contents.
* When the producer is finished making changes to a file, it should
* call close_file, to let the consumer clean up and free the baton.
*
* Function Call Ordering
* ======================
*
* There are five restrictions on the order in which the producer
* may use the batons:
*
* 1. The producer may call open_directory, add_directory,
* open_file, add_file at most once on any given directory
* entry. delete_entry may be called at most once on any given
* directory entry and may later be followed by add_directory or
* add_file on the same directory entry. delete_entry may
* not be called on any directory entry after open_directory,
* add_directory,open_file or add_file has been called on
* that directory entry.
*
* 2. The producer may not close a directory baton until it has
* closed all batons for its subdirectories.
*
* 3. When a producer calls open_directory or add_directory,
* it must specify the most recently opened of the currently open
* directory batons. Put another way, the producer cannot have
* two sibling directory batons open at the same time.
*
* 4. When the producer calls open_file or add_file, it must
* follow with any changes to the file (using apply_textdelta),
* followed by a close_file call, before issuing any other
* file or directory calls.
*
* 5. When the producer calls apply_textdelta, it must make all of
* the window handler calls (including the NULL window at the
* end) before issuing any other svn_delta_editor_t calls.
*
* So, the producer needs to use directory and file batons as if it
* is doing a single depth-first traversal of the tree.
*
* Pool Usage
* ==========
*
* Many editor functions are invoked multiple times, in a sequence
* determined by the editor "driver". The driver is responsible for
* creating a pool for use on each iteration of the editor function,
* and clearing that pool between each iteration. The driver passes
* the appropriate pool on each function invocation.
*
* Based on the requirement of calling the editor functions in a
* depth-first style, it is usually customary for the driver to similarly
* nest the pools. However, this is only a safety feature to ensure
* that pools associated with deeper items are always cleared when the
* top-level items are also cleared. The interface does not assume, nor
* require, any particular organization of the pools passed to these
* functions.
*/
typedef struct svn_delta_editor_t
{
/** Set *root_baton to a baton for the top directory of the change.
* (This is the top of the subtree being changed, not necessarily
* the root of the filesystem.) Like any other directory baton, the
* producer should call close_directory on root_baton when they're
* done.
*/
svn_error_t *(*open_root)(void *edit_baton,
apr_pool_t *dir_pool,
void **root_baton);
/** Remove the directory entry named path, a child of the directory
* represented by parent_baton.
*/
svn_error_t *(*delete_entry)(const char *path,
void *parent_baton,
apr_pool_t *pool);
/** We are going to add a new subdirectory named path. We will use
* the value this callback stores in *child_baton as the
* parent_baton for further changes in the new subdirectory.
*/
svn_error_t *(*add_directory)(const char *path,
void *parent_baton,
apr_pool_t *dir_pool,
void **child_baton);
/** We are going to make changes in a subdirectory (of the directory
* identified by parent_baton). The subdirectory is specified by
* path. The callback must store a value in *child_baton that
* should be used as the parent_baton for subsequent changes in this
* subdirectory.
*/
svn_error_t *(*open_directory)(const char *path,
void *parent_baton,
apr_pool_t *dir_pool,
void **child_baton);
/** We are done processing a subdirectory, whose baton is dir_baton
* (set by add_directory or open_directory). We won't be using
* the baton any more, so whatever resources it refers to may now be
* freed.
*/
svn_error_t *(*close_directory)(void *dir_baton,
apr_pool_t *pool);
/** We are going to add a new file named path. The callback can
* store a baton for this new file in **file_baton; whatever value
* it stores there should be passed through to apply_textdelta.
*/
svn_error_t *(*add_file)(const char *path,
void *parent_baton,
apr_pool_t *file_pool,
void **file_baton);
/** We are going to make change to a file named path, which resides
* in the directory identified by parent_baton.
*
* The callback can store a baton for this new file in **file_baton;
* whatever value it stores there should be passed through to
* apply_textdelta.
*/
svn_error_t *(*open_file)(const char *path,
void *parent_baton,
apr_pool_t *file_pool,
void **file_baton);
/** Apply a text delta, yielding the new revision of a file.
*
* file_baton indicates the file we're creating or updating, and the
* ancestor file on which it is based; it is the baton set by some
* prior add_file or open_file callback.
*
* The callback should set *handle to a text delta window
* handler; we will then call *handle on successive text
* delta windows as we receive them. The callback should set
* * handler_baton to the value we should pass as the baton
* argument to *handler.
*/
svn_error_t *(*apply_textdelta)(void *file_baton,
apr_pool_t *pool,
svn_txdelta_window_handler_t *handler,
void **handler_baton);
/** We are done processing a file, whose baton is file_baton (set by
* add_file or open_file). We won't be using the baton any
* more, so whatever resources it refers to may now be freed.
*/
svn_error_t *(*close_file)(void *file_baton,
apr_pool_t *pool)
/** All delta processing is done. Call this, with the edit_baton for
* the entire edit.
*/
svn_error_t *(*close_edit)(void *edit_baton,
apr_pool_t *pool);]
/** The editor-driver has decided to bail out. Allow the editor to
* gracefully clean up things if it needs to.
*/
svn_error_t *(*abort_edit)(void *edit_baton,
apr_pool_t *pool);
} svn_delta_editor_t;
But Is It Art?I cannot claim that the beauty of this interface was immediately
obvious to me. I'm not sure it was obvious to Jim either; he was
probably just trying to get Ben and me out of his house. But he'd been
pondering the problem for a long time, too, and he followed his
instincts about how tree structures behave.The first thing that strikes one about
the delta editor is that
it chooses constraint: even though there is no
philosophical requirement that tree edits be done in depth-first order
(or indeed in any order at all), the interface enforces
depth-firstness anyway, by means of the baton relationships. This
makes the interface's usage and behavior more predictable.The second thing is that an entire edit operation unobtrusively
carries its context with it, again by means of the batons. A file
baton can contain a pointer to its parent directory baton, a directory
baton can contain a pointer to its parent
directory baton (with a null parent for the root of the edit), and
everyone can contain a pointer to the global edit baton. Although an
individual baton may be a disposable object�—�for example, when
a file is closed, its baton is destroyed�—�any given baton
allows access to the global edit context, which may contain, for
example, the revision number the client side is being updated
to. Thus, batons are overloaded: they provide scope (i.e., lifetime,
because a baton only lasts as long as the pool in which it is
allocated) to portions of the edit, but they also carry global
context.The third important feature is that the interface provides clear
boundaries between the various suboperations involved in expressing a
tree change. For example, opening a file merely indicates that
something changed in that file between the two trees, but doesn't give
details; calling apply_textdelta
gives the details, but you don't have to
call apply_ textdelta if you don't
want to. Similarly, opening a directory indicates that something
changed in or under that directory, but if you don't need to say any
more than that, you can just close the directory and move on. These
boundaries are a consequence of the interface's dedication
to streaminess, as expressed in its introductory
comment: "...instead of representing the tree delta
explicitly, we define a standard way for a consumer to process each
piece of a tree delta as soon as the producer creates it."
It would have been tempting to stream only the largest data chunks
(that is, the file diffs), but the delta editor interface goes the
whole way and streams the entire tree delta, thus giving both producer
and consumer fine-grained control over memory usage, progress
reporting, and interruptibility.It was only after we began throwing the new delta editor at
various problems that these features began to show their value. For
example, one thing we wanted to implement was change summarization: a
way to show an overview of the difference between two trees without
giving the details. This is useful when someone wants to know which
files in her working copy have changed in the repository since she
checked them out, but doesn't need to know exactly what the changes
were.Here's a slightly simplified version of how it works: the client
tells the server what revision tree the working copy is based on, and
then the server tells the client the difference between that revision
tree and the latest one, using the delta editor. The server is the
producer, the client is the consumer.Using the repository from earlier in the chapter, in which we
built up a change to /A/fish/tuna to create
revision 2, let's see how this would look as a series of editor calls,
sent by the server to a client whose tree is still at revision 1. The
if block about two-thirds of the way through is where we decide
whether this is a summarization edit or a "give me everything"
edit: svn_delta_editor_t *editor
void *edit_baton;
/* In real life, this would be a passed-in parameter, of course. */
int summarize_only = TRUE;
/* In real life, these variables would be declared in subroutines,
so that their lifetimes would be bound to the stack frame just
as the objects they point to are bound by the tree edit frame. */
void *root_baton;
void *dir_baton;
void *subdir_baton;
void *file_baton;
/* Similarly, there would be subpools, not just one top-level pool. */
apr_pool_t *pool = svn_pool_create();
/* Each use of the delta editor interface starts by requesting the
particular editor that implements whatever you need, e.g.,
streaming the edit across the network, applying it to a working
copy, etc. */
Get_Update_Editor(&editor, &eb,
some_repository,
1, /* source revision number */
2, /* target revision number */
pool);
/* Now we drive the editor. In real life, this sequence of calls
would be dynamically generated, by code that walks the two
repository trees and invokes editor->foo() as appropriate. */
editor->open_root(edit_baton, pool, &root_baton);
editor->open_directory("A", root_baton, pool, &dir_baton);
editor->open_directory("A/fish", dir_baton,pool, &subdir_baton);
editor->open_file("A/fish/tuna", subdir_baton, pool, &file_baton);
if (! summarize_only)
{
svn_txdelta_window_handler_t window_handler;
void *window_handler_baton;
svn_txdelta_window_t *window;
editor->apply_textdelta(file_baton, pool
apr_pool_t *pool,
&window_handler,
&window_handler_baton);
do {
window = Get_Next_TextDelta_Window(...);
window_handler(window, window_handler_baton);
} while (window);
}
editor->close_file(file_baton, pool);
editor->close_directory(subdir_baton, pool);
editor->close_directory(dir_baton, pool);
editor->close_directory(root_baton, pool);
editor->close_edit(edit_baton, pool);
As this example shows, the distinction between a summary of a
change and the full version of the change falls naturally along the
boundaries of the delta editor interface, allowing us
to use the same code path for both purposes. While it happens that the
two revision trees in this example were adjacent (revision 1 and
revision 2), they didn't have to be. The same method would work for
any two trees, even with many revisions between them, as is the case
when a working copy hasn't been updated for a long time. And it would
work when the two trees are in reverse order�—�that is, with the
newer revision first. This is useful for reverting a change.Abstraction As a Spectator SportOur next indication of the delta editor's flexibility came when
we needed to do two or more distinct things in the same tree edit. One
of the earliest such situations was the need to
handle cancellations. When
the user interrupted an update, a signal handler trapped the request
and set a flag; then at various points during the operation, we
checked the flag and exited cleanly if it was set. It turned out that
in most cases, the safest place to exit the operation was simply the
next entry or exit boundary of an editor function call. This was
trivially true for operations that performed no I/O on the client side
(such as change summarizations and diffs), but it was also true of
many operations that did touch files. After all, most of the work in
an update is simply writing out the data, and even if the user
interrupts the overall update, it usually still makes sense to either
finish writing or cleanly cancel whatever file was in progress when
the interrupt was detected.But where to implement the flag checks? We could hardcode them
into the delta editor, the one returned (by reference)
from Get_Update_Editor(). But
that's obviously a poor choice: the delta editor is a library function
that might be called from code that wants a totally different style of
cancellation checking, or none at all.A slightly better solution would be to pass a
cancellation-checking callback function and associated baton
to Get_Update_Editor(). The
returned editor would periodically invoke the callback on the baton
and, depending on the return value, either continue as normal or
return early (if the callback is null, it is never invoked). But that
arrangement isn't ideal either. Checking cancellation is really a
parasitic goal: you might want to do it when updating, or you might
not, but in any case it has no effect on the way the update process
itself works. Ideally, the two shouldn't be tangled together in the
code, especially as we had concluded that, for the most part,
operations didn't need fine-grained control over cancellation
checking, anyway�—�the editor call boundaries would do just
fine.Cancellation is just one example of an auxiliary task associated
with tree delta edits. We faced, or thought we
faced, similar problems in keeping track of committed targets while
transmitting changes from the client to the server, in reporting
update or commit progress to the user, and in various other
situations. Naturally, we looked for a way to abstract out these
adjunct behaviors, so the core code wouldn't be cluttered with
them. In fact, we looked so hard that we
initially over-abstracted: /** Compose editor_1 and its baton with editor_2 and its baton.
*
* Return a new editor in new_editor (allocated in pool), in which
* each function fun calls editor_1->fun and then editor_2->fun,
* with the corresponding batons.
*
* If editor_1->fun returns error, that error is returned from
* new_editor->fun and editor_2->fun is never called; otherwise
* new_editor->fun's return value is the same as editor_2->fun's.
*
* If an editor function is null, it is simply never called, and this
* is not an error.
*/
void
svn_delta_compose_editors(const svn_delta_editor_t **new_editor,
void **new_edit_baton,
const svn_delta_editor_t *editor_1,
void *edit_baton_1,
const svn_delta_editor_t *editor_2,
void *edit_baton_2,
apr_pool_t *pool);
Although this turned out to go a bit too far�—�we'll look
at why in a moment�—�I still find it a testament to the beauty
of the editor interface. The composed editors behaved predictably,
they kept the code clean (because no individual editor function had to
worry about the details of some parallel editor invoked before or
after it), and they passed the associativity test: you could take an
editor that was itself the result of a composition and compose it with
other editors, and everything would just work. It
worked because the editors all agreed on the basic shape of the
operation they were performing, even though they might do totally
different things with the data.As you can tell, I still miss editor composition for its sheer
elegance. But in the end it was more abstraction than we needed. Much
of the functionality that we initially implemented using composed
editors, we later rewrote to use custom callbacks passed to the
editor-creation routines. Although the adjunct behaviors did usually
line up with editor call boundaries, they often weren't appropriate
at all call boundaries, or even at most of
them. The result was an overly high infrastructure-to-work ratio: by
setting up an entire parallel editor, we were misleadingly implying to
readers of the code that the adjunct behaviors would be invoked more
often than they actually were.Having gone as far as we could with editor composition and then
retreated, we were still free to implement it by hand when we really
wanted it, however. Today in Subversion,
cancellation is done with manual composition. The
cancellation-checking editor's constructor takes another
editor�—�the core operation editor�—�as a
parameter: /** Set *editor and *edit_baton to a cancellation editor that
* wraps wrapped_editor and wrapped_baton.
*
* The editor will call cancel_func with cancel_baton when each of
* its functions is called, continuing on to call the corresponding wrapped
* function if cancel_func returns SVN_NO_ERROR.
*
* If cancel_func is NULL, set *editor to wrapped_editor and
* *edit_baton to wrapped_baton.
*/
svn_error_t *
svn_delta_get_cancellation_editor(svn_cancel_func_t cancel_func,
void *cancel_baton,
const svn_delta_editor_t *wrapped_editor,
void *wrapped_baton,
const svn_delta_editor_t **editor,
void **edit_baton,
apr_pool_t *pool);
We also implement some conditional debugging traces using a
similar process of manual composition. The other adjunct
behaviors�—�primarily progress reporting, event notification,
and target counting�—�are implemented via callbacks that are
passed to the editor constructors and (if nonnull) invoked by the
editor at the few places where they are needed.The editor interface continues to provide a strong unifying
force across Subversion's code. It may seem strange to praise an API
that first tempted its users into over-abstraction, but that
temptation was mainly a side effect of suiting the problem of streamy
tree delta transmission exceptionally well�—�it made the problem
look so tractable that we wanted other problems to become that
problem! When they didn't fit, we backed off, but the editor
constructors still provided a canonical place to inject callbacks, and
the editor's internal operation boundaries helped guide our thinking
about when to invoke those callbacks.ConclusionsThe real strength of this API, and, I suspect, of any good API,
is that it guides one's thinking. All operations involving tree
modification in Subversion are now shaped roughly the same way. This
not only reduces the amount of time newcomers must spend learning
existing code, it gives new code a clear model to follow, and
developers have taken the hint. For example,
the svnsync feature, which mirrors one
repository's activity directly into another repository�—�and was
added to Subversion in 2006, six years after the advent of
the delta editor�—�uses the delta
editor interface to transmit the activity. The developer of that
feature was not only spared the need to design a change-transmission
mechanism, he was spared the need to
even consider whether he needed to design a
change-transmission mechanism. And others who now hack on the new code
find it feels mostly familiar the first time they see
it.These are significant benefits. Not only does having the right
API reduce learning time, it also relieves the development community
of the need to have certain debates: design discussions that would
have spawned long and contentious mailing list threads simply do not
come up. That may not be quite the same thing as pure technical or
aesthetic beauty, but in a project with many participants and a
constant turnover rate, it's a beauty you can
use. | 2024-11-08T20:53:31 | null | train |
62,885 | nickb | 2007-10-04T02:52:26 | Short, concise and readable code - invert your logic and stop nesting already! | http://javathink.blogspot.com/2006/10/short-concise-and-readable-code-invert.html | 10 | 1 | [
63264
] | null | null | null | null | null | null | null | null | null | train |
|
62,886 | nickb | 2007-10-04T02:54:14 | The problem with the computer industry under capitalism - Free Software the answer? | null | http://www.marxist.com/computer-industry-capitalism-free-software240907.htm | 1 | 0 | null | null | null | no_error | The problem with the computer industry under capitalism - Free Software the answer? | null | Maarten Vanheuverswyn | The way the computer industry functions today is a perfect illustration of all the faults and massive inefficiencies of capitalism, where the primary goal is not serving the interests of society. Developing, improving and distributing software takes place only where big profits can be made. This stands in sharp contrast to free software, where human knowledge and the produce of human labour is used to the advantage all of society.This article deals with computer software. That may sound a bit abstract to some of our readers, but it is a subject that is relevant to everybody who uses a computer, for example to read this very article. You should care about the way the computer industry functions today and the way it imposes severe restrictions on us since you may one day no longer be allowed to listen to your MP3's or read your Microsoft Word documents. You may think you will be able to continue these simple tasks forever because you believe you actually own and control most of what is stored on your computer. However, according to big business that is not the case.Not only do you not own that copy of Microsoft Word, that video game, or even that MP3 player, but like most people using commercial software (be it pirated or paid for in a shop), you also don't own any other way of accessing your information. To this you can reply: "But I will always have my computer because it is mine, and nobody can stop me listening to my music collection!" Maybe so, but not necessarily. To understand that, however, we must first delve into the murky world of software licences.A "software licence" is a form of contract and has become the most common form of software distribution today. When installing a new programme on your computer you may recall having to click "I Agree", or "OK", or something to that effect. That was you signing a contract that you probably never read in the first place. For the moment we are going to take a rather simplistic approach and divide all software licences (contracts) into two, distinct categories. We will call them "Closed" and "Open". Let's start with "Closed" licences, as they are currently the most common type.Closed licences are usually fairly restrictive with regard to what you are (and are not) allowed to do with the software in question. When you buy a copy of, for example, Windows XP or Windows Vista, you are typically only allowed to use one licence per computer, you are not permitted to pass copies on to any friends, you are most certainly not allowed to resell it, and you are in no way permitted to make changes to the software. A licence to run Let's take a moment to examine our MP3 player a little closer. Actually, we don't own the programme that plays our Britney Spears album, even though we paid good money for both the programme and the album in question (whether Britney Spears is worth much money is another question altogether of course). But what about our little iPod itself? Surely you can own one of those? Again, the answer is both yes and no. Although you may have bought the actual physical little box, you have only licensed a copy of the programme running on the device. All we have paid for is permission to use the programme.The important thing to note here is that most closed software licences don't actually sell you anything you can keep; they merely give you permission to run the software under a very specific set of circumstances. A computer programmer can write a little computer game and decide to license it for sale with, for example, the clause "this game may only be used when wearing a dark red jumper and yellow trousers". Legally speaking, those without dark red jumpers and yellow trousers are not permitted to run the programme, even after they have paid money to the programmer. Here is where the distinction between licensing (renting) and purchasing (buying) software becomes important. When people say "I am going to buy a copy of Photoshop," they actually mean "I am going to buy a licence to run a copy of Photoshop, and hope that I meet all the criteria stipulated in the licence contract." This form of agreement is called an end user licence agreement or EULA.Purchasing implies ownership, and we all know that although you can do whatever you want with a car you own, you should not try to add new wheels or a spoiler to a rental car. We have come to an agreement with the rental company that we hand over some money in exchange for which we are allowed to use the car. However, if we abuse the car then the owner has every right to stop us from using it. It is the same principle in the computer world.At this point one can object: "So what? I run Microsoft Word. It does what I want. Why should I care? They cannot come into my house and take it away from me." That brings us to the next part: control. To illustrate this point, we need to go back to our example of the MP3 files. An MP3 file is in essence a compressed version of a song as you find it on an audio CD. The way those MP3's you are playing seem to magically compress all that music into a small file was originally developed and published by a German research organisation called the Fraunhofer Institute. It is their so-called intellectual property. But even though they are giving you instructions on how to use their method for storing music, that does not mean you can do whatever you want with it. For example, any product that makes money out of MP3's must pay a royalty to the Fraunhofer Institute. This German organisation invented and patented the MP3 compression algorithm and now they are making about €100,000,000 in licence revenue per year.That is all well and good, and not a real problem, you may say. After all, you are not the one paying these royalties to them and you are happy to just use your media player on your computer, which usually includes the licence to play MP3 files. The problem is that it is perfectly within their legal right to actually stop you from using it. That means that even though we know how MP3's work, the people that own the intellectual property rights to MP3's always control who may use them. So, perhaps one day they will decide that they don't want anybody using them, and that everyone should move on to MP4. And then MP5. In this way the Fraunhofer Institute always retains control.Of course you can say: "Well, when that happens I will just switch to a different product. They know I would switch, so they would never do such a thing." The problem is that software companies use a more subtle tactic to both keep their user base and still force them to upgrade (and thus make more profit). For example, if you write a text in Microsoft Word and save it, Word will save it as a "Microsoft Word Document." Here is where the problems start. Nobody in the world really knows how to open a Word document, except Microsoft. There is nothing illegal about that; it is their own standard they use to open and save their documents. The issue is now that anyone who wants to be absolutely sure that they are correctly opening a Word document is required to use (and pay for) a copy of Word, sold only by Microsoft. Sure, some people have done an excellent job of guessing how they work (OpenOffice.org, for example) but they are never 100% sure. We are now required to pay someone money to be able to communicate with each other, or listen to our music.In the case of Microsoft Word, the situation is even worse. Microsoft has the nasty habit of changing their own file formats every few years. If you have recently bought a copy of Microsoft Office 2007 and you save your document in the latest .docx format, then your friend who you are sending your document to will not be able to open your file at all if he is still running an older version of Microsoft Word. So even if you decide to be a good citizen and pay for a licence of Microsoft Word, there is no guarantee that you will always be able to exchange documents with friends or colleagues as different versions of the same programme can be mutually incompatible. The only solution, apart from manually selecting a better documented file format like RTF, is to keep upgrading (and paying for) your software, but even then you never have an absolute guarantee that your documents will appear exactly the same on your friend's screen as on yours.Closed and open standardsAt this point it is useful to say a few words about something called "Standards." A standard is a way for something to work. MP3 is a standard. DVD is a standard. PDF is a standard. HTML (the language of the World Wide Web) is a standard. In the non-computer world, the Phillips head screw is a standard. Standards allow you to buy a wheel that fits a car, and a nut that fits a bolt. Most of the time people can simply look at a standard - such as the Phillips head screw - and say "Okay, now I can make a Phillips head screw head screwdriver, because I can see how this thing works." Unfortunately, in the world of computers it is possible to have things called "Closed Standards", where it is impossible to "see" how things work. If the person who designed the system does not explicitly tell you how something works then you will not be able to imitate it. For example, if you wanted to create a programme that could save Microsoft Word documents then, as we pointed out above, the only way to do this is to guess how the Microsoft Word format works. This is especially troubling since many government institutions use this format as their de facto standard, so in effect tons of crucial information are stored in a format that nobody really knows how to open or save, except one company called Microsoft.This use of closed standards results in what is known in the industry as "Vendor Lock-In", where as a customer you become so dependent on a vendor for products or services that moving to another vendor would be too expensive or too much of a hassle. This is a well known strategy of large software houses. It is one of the reasons why Bill Gates managed to become a billionaire, not because he was such a genius but because with his predatory tactics he was able to tie millions of computer users to his company (more about this in our article Bill Gates, saviour of the world?). You must keep buying products from the same company if you want to keep up to date software, and it is too bad if they decide to no longer support a feature you really need. Some banks are still using ancient versions of the OS/2 operating system because the company that once made their proprietary banking software, which only runs on this old operating system, ceased to exist so these banks are now stuck with it.So, how can we actually have complete control over the files we save? Well, as we said before, some companies publish full specifications of their file formats - such as Adobe with their PDF files, and the Fraunhofer institute, with MP3's - allowing us to create tools to, say, play our MP3's, or convert a bunch of MP3's into an audio CD. Even though companies still retain the intellectual property rights to these formats, we have (as a gesture of goodwill) been given complete blueprints on how to use them. So, should we all just use well-documented formats? That would be a step in the right direction but it is not enough to become truly independent of third parties keen to make a profit. As we found out earlier with the example of the MP3 files, if you use someone else's method for storing information (be it music, photos or essays) they still retain the right to decide who may use their method and to charge royalties. Companies in a capitalist world are in the business to make money in the first place after all.Who then can I actually buy software from, and be able to do with it what I like? Actually, some people are giving it away. There is the example of PDF files, which is a truly open standard. Every software programmer can find out how the PDF format works because Adobe, the company that created the standard, has given complete instructions on how to use, create, save and print so-called PostScript documents - all without having to pay any royalties. This will remain the case forever, so even if Adobe goes bankrupt, we would still be able to read and write PDF documents. This is not the case if you have bought a song from, for example, an online store like iTunes, which usually comes in a restricted format from Apple that you can only play on an iPod and not on any other MP3 player.The second type of software licence we mentioned at the very beginning was "open" software. Most open licences, with some minor differences, allow you to add, remove or modify anything you like. They give the software away. You may initially have to pay for a copy, but when you click "I Agree" on a copy of Red Hat Linux you are, from then on, permitted to do whatever you like with the software. If there is a feature you want, then you (or that friend of yours down the road who is pretty good with that sort of thing) may add it. If you want to add lots of features and sell it to someone else, that is allowed too. Or you could just keep on using OpenOffice, an open source word processing programme, happy in the knowledge that you will always, no matter what, be able to get to your documents. The spirit of "Open" is that no single person should be dependent on any third party to use their own property.Just as with closed standards, there are things called "Open Standards." An open standard defines how something works, but it isn't owned by anybody. Sure, there may be some non-profit organisation in charge of maintaining a reference, but no one needs to pay money to write a HTML web page, since it is an open standard.Now imagine combining the power of open software and open standards. Anyone could communicate perfectly with anyone else, without being dependent on any third party. This is happening today. It is called Open Source, or to use a better term, "free software". Free software versus proprietary softwareFree software represents a fundamental break with the closed model. You still get a licence to the software but the licence is intended to empower the users of the software. You are explicitly entitled to make copies (and encouraged to do so) and the software product itself is not seen as a private asset but as a public resource.The term "free software" suggests a free lunch. One may think this simply means that you don't have to pay for the software. In most cases that is true, but not always. In this context "free" corresponds to the meaning of the French term libre, so it does not necessarily mean gratis. It is about freedom, not price. Or as free software advocates like to put it: free as in free speech, not as in free beer. It is a matter of the users' freedom to use, share, study and improve the software.Such freedom is in stark contrast to how big business distributes and uses software. For these companies, control over software means control over its source code. Computer programmes are written in a human-readable language (source code), which is translated into the machine language format the computer executes. Machine language is much harder for people to understand and, by implication, modify. By keeping the source code secret, software companies are able to exercise control of how their programmes are used and what functions they can offer. An increasing trend is to use this control to ensure that their intellectual property is preserved. Free software is the polar opposite in which the licence is used to protect the freedom of the end users.This freedom provides huge benefits to society. Access to source code means that the underlying functionality of software can be inspected, and therefore trusted, and also modified and improved. Flaws in the software can be more easily found and fixed in the interests of all and for the benefit of all. Parts of the source code can be shared among programmers and re-used in other related or new projects. This collaboration encourages sharing human knowledge and saves countless hours of labour in software development as everything only needs to be invented once. The freedom to run and distribute software to whoever needs it, means that all of society benefits, in many cases at no extra cost.In order to protect these freedoms, various licences have come into existence. By far the most famous one is the GPL licence, which stands for GNU General Public Licence. The GPL was written by Richard Stallman in 1989, whose goal it was to produce one licence that could be used for any free software project, thus making it possible for many projects to share code. This GPL licence quickly became the single most popular licence for free software after Linus Torvalds, the founder of the Linux operating system, adopted the licence for the Linux kernel in 1992.The advantage of the GPL licence is that instead of copyright, it imposes a strong copyleft on the software licensed under it. Basically this means that all modified versions of the software must in turn be licensed under the GPL. A piece of software that uses GPL code in turn has got to make its source code available for others. The copyleft thus uses copyright law to accomplish the opposite of its usual purpose: instead of imposing restrictions, it grants rights to other people, in a way that ensures the rights cannot subsequently be taken away.Microsoft CEO Steve Ballmer once referred to the GPL as "a cancer that attaches itself in an intellectual property sense to everything it touches." Ballmer here, of course, wants to discredit the whole open source movement by spreading fear, uncertainty and doubt. The truth is that the GPL licence "infects" only derivative works of GPLed software, that is, if as a programmer you decide to distribute your software, which you have based on an existing piece of software. We would argue that the GPL is like a benign, liberating virus that infects all software that is written under the licence in order to ensure that the source code will always remain open and can be used for the good of society. The GPL was crucial to the success of the GNU/Linux operating system, giving the programmers who contributed to it the confidence that their work would benefit the whole world and remain free, rather than being exploited by software companies that would not have to give anything back to the community.Conversely, the closed software approach embodies all the faults and massive inefficiencies of capitalism, where the primary goal is not serving the interests of society, nor innovating, nor improving or fixing software - all those interests come a far second to the primary goal of generating profits. Developing, improving and distributing software takes place only where big profits can be made. Flaws in Microsoft Windows only supply Microsoft with yet more leverage to restrict software, by obliging people to have a licensed copy in order to get access to essential security updates.Proprietary software can neither be studied nor modified by the public and gives software companies the power to maintain big monopolies and making life difficult for their competitors. This stifles advances in technology - Microsoft has been many times the monopoliser but rarely the innovator. When the fruits of the labour of developers under private companies are restricted, and their source code kept a secret, the labour power of society is squandered wastefully as other developers are forced to start from scratch if they want to enter the software market. The task of protecting source code and concealing knowledge has become a big industry, yet these efforts are totally superfluous to free software, where human knowledge and the produce of human labour is used to the advantage all of society.The collaborative process of free software has already proven its success by the millions of people involved and the hundreds of thousands of open source projects that have been produced, including spectacular success stories such as the Apache web server, which serves 50% of the Internet, and OpenOffice and Mozilla Firefox, which have tens of millions of users worldwide.Contradictions in the free software movement There are two major philosophies concerning the creation and use of freely available software, known as the free software and open source models. The term "free software" is older than "open source". "Free software" is used by the Free Software Foundation founded by Richard Stallman in 1985. The term "open source", on the other hand, has been developed by Eric Raymond and others, who, in 1998, founded the Open Source Initiative.Why is there a distinction and why is it important? In order to tackle these questions, we have to take a look at the history of the free software movement.The free software movement fractured in the late nineties into two camps: the free software movement proper and the open source movement. The tensions had existed for a long time beforehand and centre on the difference in philosophy between the advocates of each movement.On the one hand, the free software camp tended to proceed from ethical or moral arguments about the harmful effects of proprietary software. This, coupled with the GNU Public Licence which was perceived as being unfriendly to business (and often said to be anti-commercial), prompted the creation of the open source camp. The latter sought to win the support of big business and so emphasized the technical superiority of the software resulting from the "open" development process.This contradiction has been there from the beginning. Richard Stallman, founder of the free software movement had ensured that the licence that granted end user freedoms could not be used by business to undermine the original effort. One right that is not granted by the original GPL free software licence was to incorporate free software into commercial products. If a company does this it must make its own product also free software, which explains Steve Ballmer's "virus" remark.The open source advocates pursued a strategy of winning support from big business and were successful in getting large corporations like IBM to back them. The free software community had shown how amateurs organised into loose teams across the globe can outperform even the disciplined legions of developers employed by Microsoft. The open source community sought to exploit this process but to remove the anti-capitalist ethos that seemed to bedevil free software. This led to the creation of several successful not-for-profit foundations such as Apache that can pay developers to work on open source. Unsurprisingly, the free software movement has found itself pushed to the periphery as its moral crusade failed to resonate with many people.The true significance of the free software model is a political one. Thousands of computer programmers all over the world work together on a common project and they share their computer code in order to arrive at a good product that everybody is able to use. It shows in practice that even in this capitalist world it is possible to collaborate rather than be in competition with each other. It shows that it is a myth that people will only do things for money or for profit.Having said that, it would be wrong to idealise the open source or free software model. What we see now is only a tiny fraction of its potential. It is not correct to say that open source equals socialism. Technology is not neutral. The fact that free software is still a very marginal phenomenon (most people use Windows or Mac, which is equally "closed") shows that there is a long way to go before we will be able to exchange our information in an open format, free of charge, without dependence on a monopolist player like Microsoft.Software, a very profitable commodity As we mentioned above, it is not the software itself that is bought and sold, but a licence to use that software. Such a licence is a commodity when it has a social use value to society and when it originates from the expenditure of human labour power. In major software development, this expenditure can be massive. Many hundreds of thousands of hours of development time were necessary to create operating systems such as Microsoft Windows and programmes such as Microsoft Office. However, due the immaterial nature of software - unlike other commodities - it can be reproduced many times at virtually no cost at all and the original capital outlay can be recovered rapidly. In many cases, software licences such as the case of Microsoft Office, have gone on to become "cash cows", which continue to gather big profits via millions of sales, even though development may stagnate for many years at a time.Most companies simply do not have such a big capital outlay to even begin to compete directly with Microsoft. Without a significant share of the market, such a heavy investment would not be rewarded. There is no "branching" into new projects possible like in the open source movement, and any software competing with Microsoft would have to wastefully start the technology from scratch and would then meet head on with Microsoft, well-known for its various anti-competitive and monopolistic practices.Karl Marx explained the ever increasing "concentration of capital" inherent to capitalism. In the software industry, like all other industries, this means that the small players are forced out - "their capitals partly vanishing, partly disappearing into the hands of the conqueror", and this has left Microsoft with obscene profits and essentially unbridled reign over the industry. Microsoft is then able to perpetuate its own monopoly by ensuring that new PC's come with the operating system pre-installed, the use of non-free propriety formats such as Microsoft Office formats, and it can be certain that all new hardware comes with built-in support for Windows. This ensures an unbreakable dependence on the software in spite of any inferior qualities.Since the beginning of the 20th century capitalism manifested itself as monopoly capitalism which was well explained by Lenin in his classic work Imperialism - The Highest Stage of Capitalism. In the present capitalist system, competition is generally presented as something inherently positive, which stimulates innovation, creativity and originality. That view is fundamentally false, and it is no less false in the case of Microsoft's monopoly on much of the software industry, which has provided the company with less and less need to innovate. Development of its products slows and its faults are tolerated. Microsoft prefers to protect its herd of "cash cows" than meet the needs of people, and it continues to place its efforts on eliminating competition rather than benefiting from it in a healthy way.Socialism and Free SoftwareLarge companies use their monopoly control to impose de facto standards. In itself standardisation is a very positive thing. When buying a new computer, it makes sense to have all the necessary software available without any further costs. It also helps that computers use the same formats so that documents, audio files etc. can be exchanged without problems. The negative aspect of this kind of standard is that the selfsame companies use these proprietary standards to further reinforce their monopoly. A significant part of the world economy now depends on these standards (Microsoft Word documents being the prime example of this) and the critical decisions are made by private companies who have no accountability at all.This is where technology becomes political. The only power that is able to effectively promote open standards and free software in general is a political power. Right now the problem is that many open source projects are rather amateurish and end up nowhere because of lack of financing. Often (though certainly not always), hobbyist projects simply cannot compete with the commercial, closed and proprietary software that has thousands of professional programmers behind it. At this stage, for example, it would be very hard for most graphic designers to switch over to free software as in this domain it is simply not up to scratch yet. Their only option at this stage is to use specialised software from companies like Adobe or Macromedia.The solution to the present chaos in the computer world is not to just convince everybody to switch to Linux operating systems or to only use open source software and avoid proprietary software. Of course that would be a step in the right direction, but we need to see the limits of a moralist approach like this. It is a myth to think that in a capitalist world you can somehow create a fair haven while the system itself only creates inequality and injustice. Free software can only be the "germs" of a new society, as it cannot involve the total production. For the free software movement to truly take prime position, society has to change. We need to change the capitalist mode of production and replace it with a socialist one, based on cooperation and sharing of information.In a genuine socialist society (not the monstrous caricature that existed in the former Stalinist countries) there would be no reason for competition beyond the type of competition we see in sports. Instead various kinds of fruitful cooperation would take place. You can see that today not only in free software but also (partly) in science and, for instance, in cooking recipes. Imagine your daily meal if cooking recipes were proprietary and available only after paying a licence fee instead of being the result of a world-wide cooperation of cooks. A socialist society would seek to harness radically improved working patterns now afforded by technology and open source and free software foreshadow some of the possibilities of how society can be run democratically and efficiently.In order to remove the existing fetter on technological development we need to enable radical change in the way software is produced. Imagine if the source code of Microsoft's and other private companies' software were made publicly available so that all software could be freely distributed and further developed to the benefit of the whole of humankind. The free software movement is a foretaste of how engineering - not just in software - might be organised once it is freed from the constraints of private profit.To conclude with what we said in our article on Bill Gates:"What is needed is a transfer of all available computer technology to a form of social ownership, linked with a democratic world socialist government that would finally put all available resources and technology to the public's use. That, in turn, requires a socialist transformation of society that would abolish the profit system and establish a worldwide democratically controlled economic system where production is based on the needs of mankind."CreditsThis article was first and foremost a collaborative effort. Thanks to Steve from Australia, Emil from Great Britain and Jesse from New Zealand for their valuable contributions and comments. Credit is also due to Sean Cohen, the author of the article Why Free Software Matters, which served as the basis of and inspiration for the present article.See also: Intellectual property rights – the modern day enclosure of the commons by Mick Brooks (November 22, 2005) Bill Gates, saviour of the world? by Maarten Vanheuverswyn (March 17, 2005) | 2024-11-08T10:28:34 | en | train |
62,888 | transburgh | 2007-10-04T03:12:43 | Open Thread: To Hack or Not to Hack, That is the Question | null | http://webworkerdaily.com/2007/10/03/open-thread-to-hack-or-not-to-hack-that-is-the-question/ | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
62,889 | nickb | 2007-10-04T03:12:48 | Venture Capital's Hidden Calamity | null | http://www.businessweek.com/technology/content/oct2007/tc2007102_411316.htm | 6 | 0 | null | null | null | null | null | null | null | null | null | null | train |
62,891 | far33d | 2007-10-04T03:18:39 | A Two Year Old Feature Request Fulfilled (by disqus) | http://avc.blogs.com/a_vc/2007/10/a-two-year-old-.html | 15 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,893 | amichail | 2007-10-04T03:35:20 | A pot of burning chilli sparked fears of a biological terror attack in central London. | http://news.bbc.co.uk/1/hi/england/london/7025782.stm | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,895 | axiom | 2007-10-04T03:38:37 | Programming Language Video Lectures | null | http://freescienceonline.blogspot.com/2007/09/programming-language-video-lectures.html | 6 | 0 | null | null | null | null | null | null | null | null | null | null | train |
62,896 | german | 2007-10-04T03:49:51 | Startup News or Hacker News? | Have anyone noticed that in YCombinator library (<a href="http://ycombinator.com/lib.html" rel="nofollow">http://ycombinator.com/lib.html</a>) the Hacker News link still appears like Startup News?<p>It's not so important but it is just a little HTML change, so I believe it must be done. :P | 1 | 0 | null | null | null | invalid_url | null | null | null | null | 2024-11-08T16:37:59 | null | train |
|
62,897 | daveb | 2007-10-04T03:52:35 | Narayana Murthy's dream for the future | http://im.rediff.com/money/2005/aug/12bspec.htm | 4 | 2 | [
62993
] | null | null | no_error | Narayana Murthy's dream for the future | null | null |
India's software giant Infosys Technologies Limited has entered its 25th year of existence. In these 25 years, the company has scaled many a peak, making the nation proud of it.N R Narayana Murthy, Chairman, Infosys [Get Quote], however, has plans to turn the company into a bigger, stronger, and global player.At an analysts' meet, held to mark the silver jubilee celebrations of Infosys in Hyderabad, Murthy spoke about his future for the company.Here's the speech that he delivered.We start our 25th year celebrations today. It is indeed laudable that we have run this marathon so far. Several happy thoughts come to my mind as I stand here. But, the most important one is our meeting in January 1981.How Infosys beganIt was a wintry morning in January 1981 when seven of us sat in my apartment, and created Infosys. We had lots of hope, confidence, commitment, energy, enthusiasm, hard work, passion and a sense of sacrifice.We were short of one thing, money. We managed to put together just $250 in seed capital.We never dreamt about size, revenues and profits. Our dream, right from day one, was to build a corporation that was, above all things, respected.From the beginning, our team was unique in our commitment to a strong value system. We believed in putting the interest of the company ahead of our own interest. We believed in legal and ethical business.We believed in respect and long-term gratification. And each of us brought complementary strengths to the company.'Entrepreneurship is a marathon'To me, entrepreneurship is a marathon. I believe that the key to a successful corporation is longevity � my heroes are companies like IBM, Levers, and GE. These firms have shown growth in earnings quarter after quarter, for a long time.Infosys itself has seen consistent growth in revenue and profitability for over 49 quarters, since it got listed in India. We have institutionalized performance and accountability in our systems and processes, and through the empowerment of our employees. Let me talk about some of the generic lessons we have learnt.The name of the game is: predictability of revenues; sustainability of the prediction; profitability; and a good de-risking model. Measurement is key to improvement.Value systemA sound value system is what differentiates long-term players from others. Putting the corporation's interest ahead of personal interest will advance personal goals in the long term.No single person is indispensable. It is important that you give challenging engagements to deserving people, whether they are young or new in the organization. Youth and empowerment are the keys to scalability and longevity.Every situation is what you make it to be. Confidence is half the battle, and leadership is making the impossible look possible. Speed, imagination and excellence in execution are the only three context-invariant and time-invariant attributes for success.Trust of employees, investorsThe trust of employees is the most important ingredient for successful leadership. To gain the trust of people, there is no more powerful leadership style than leadership by example. The world respects performance and action, not rhetoric.It is better to obsolete our own innovations, rather than allowing our competitors to do it. A healthy sense of paranoia and respect for competition is an absolute must for success. It prevents complacency, and ensures that the organization is learning continuously. The ultimate test for customer satisfaction is making our customer look good in front of his / her customer.I have realized that if you want to look smarter, you must surround yourself with people smarter than you. Everybody needs incentives to perform. Money is not the only motivator; respect, dignity, fairness and inclusiveness are essential to get the best out of employees. Every employee must feel an inch taller when talking about the company.Being transaction-oriented in every decision avoids groupism. An emphasis on meritocracy and data-orientation enhances the confidence of employees in the fairness of the corporation. We believe in the adage, In God we trust, everybody else brings data to the table.To retain the trust of your investors, it is better to under promise and over-deliver. Investors understand that every business will have ups and downs, and want us to level with them at all times. They want us give them bad news pro-actively and as early as possible. Therefore, When in doubt, disclose.We have realized that we should never take any decision with the stock price in mind. The day we do this, we will ruin the company. Finally, we have realized that we can shortchange investors if we want to make Rs 1 crore (Rs 10 million), but if we want to make Rs 1,000 crore (Rs 10 billion), we have to play the game straight and honest.We have realized that longevity requires that we follow every law of the land, even if we do not agree with it. We should work hard to change laws that hurt the progress of the corporation.Unless we make a difference to the society and earn their trust, we cannot be long-term players. Therefore, in everything we do, we must ask ourselves whether we are adding value to the society around us, regardless of where we are -- US or India.'What I want Infosys to achieve in 25 years'What do I want to see this company achieve in the next 25 years? I want this to be a place where people of different races, nationalities and religious beliefs work together, in an environment of intense competition but utmost courtesy and dignity, to add greater and greater value to our customers, day after day. Just like we have received respect in India, I want Infosys to be the most respected company in every country that it operates.But, to achieve these dreams, we have to be in existence over the next 250 years. I know we can do this for the following reasons: We have an extraordinary leader in Nandan (Nandan Nilekani, Infosys CEO), a man of great vision, values and dynamism. He is ably supported by the best management team and professionals in the industry.We have a depth of leaders within the organisation, with over 500 leaders being part of our leadership training and mentoring programme.The de-risking strategy at Infosys ensures that there is a backup for every position, and that decision-making is participatory across the company. In other words, it is not one person, but a team that looks at every decision. Thus, at Infosys, it is the leadership of ideas and meritocracy that drives every decision.Every decision is supported by a strong portfolio of systems, processes and technology.The value system of the company is time and context invariant.We will continue to have the mindset of a small company even as we grow and scale.Finally, and most importantly, I see youth, the feel-good factor and confidence around me.This is why I am confident Infosys will continue to serve the society as a long-term player.Thank you.N R Narayana Murthy
More Specials | 2024-11-08T11:07:12 | en | train |
|
62,900 | karzeem | 2007-10-04T04:05:00 | The Paradox of Choice Illustrated with Jam Tasting | http://blogs.intel.com/research/2007/10/parallel_programming_environme.html | 3 | 2 | [
62951,
63443
] | null | null | null | null | null | null | null | null | null | train |
|
62,903 | chaostheory | 2007-10-04T04:15:31 | Internet Business is killing the 80/20 rule | http://businessshrink.biz/psychologyofbusiness/2007/10/02/internet-business-is-killing-the-8020-rule/ | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,913 | karzeem | 2007-10-04T06:01:51 | Physician with a Slick, Web 2.0-ish Method of Practice | http://www.jayparkinsonmd.com/ | 56 | 25 | [
62949,
62925,
62955,
62963,
62947,
63087,
63469,
63109,
62937
] | null | null | null | null | null | null | null | null | null | train |
|
62,923 | maurycy | 2007-10-04T06:24:28 | What are the Rails plugins you miss the most? | 1 | 0 | null | null | null | invalid_url | null | null | null | null | 2024-11-08T16:37:59 | null | train |
||
62,928 | rms | 2007-10-04T06:50:10 | What kids like to do online | http://www.slate.com/id/2173912/nav/navoa/ | 3 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,932 | gigamon | 2007-10-04T07:03:37 | How to Turn Your VC into Your Worst Enemy? | VC's have been my best friends and my worst enemies, in ways that are not always within my immediate control. In the process, ironically, I have come to respect Venture Capitalist as a profession, which I believe is the least understood if not the most misunderstood. And I am convinced that mistakes I have made with VC's (eventually turning them into my worst enemies) were a result of my inexperience as a CEO compounded by a total lack of understanding of who VC's are and what they do for a living. | http://www.lovemytool.com/blog/2007/10/vc-worst-enemy.html | 3 | 1 | [
63036
] | null | null | null | null | null | null | null | null | null | train |
62,939 | willphipps | 2007-10-04T08:12:22 | Ballmer: Facebook risks being 'a fad' | http://business.timesonline.co.uk/tol/business/industry_sectors/technology/article2573297.ece | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,942 | davidw | 2007-10-04T08:17:09 | Multitenancy and the network effect | http://www.roughtype.com/archives/2007/10/multitenancy_an.php | 3 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,943 | willphipps | 2007-10-04T08:17:55 | Future of Web Apps - Malik and Arrington | http://blogs.guardian.co.uk/technology/2007/10/03/future_of_web_apps_malik_and_arrington.html | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,945 | davidw | 2007-10-04T08:28:06 | In Thrall to Scarcity - Open Source & Business | http://journal.dedasys.com/articles/2007/02/03/in-thrall-to-scarcity | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,961 | dpapathanasiou | 2007-10-04T10:59:09 | ThinkGeek's Clip-on 8-Bit Tie: An April Fool's Joke Becomes a Real Product | http://www.thinkgeek.com/apparel/hats-ties/9352/?cpg=59T | 3 | 1 | [
62962
] | null | null | null | null | null | null | null | null | null | train |
|
62,967 | Tichy | 2007-10-04T11:50:19 | Ask YC: how to create Web 2.0 beta flares? | Couldn't find a tutorial for the Gimp. What is the usual way to create them? If I steal them from somewhere, I won't have antialiasing... | 1 | 0 | null | null | null | invalid_url | null | null | null | null | 2024-11-08T16:37:59 | null | train |
|
62,970 | markpeterdavis | 2007-10-04T12:12:28 | VC's Concerns About Successful Entrepreneurs | VCs generally get excited about backing entrepreneurs that have already successfully exited a venture. However, the stereotype of the repeat entrepreneur brings with it a concern... | http://getventure.typepad.com/markpeterdavis/2007/10/concerns-about-.html | 3 | 0 | null | null | null | null | null | null | null | null | null | null | train |
62,974 | robertgaal | 2007-10-04T12:29:11 | How did you guys like PG's talk at FOWA '07 this morning? | null | 3 | 7 | [
62976,
63117,
63000
] | null | null | invalid_url | null | null | null | null | 2024-11-08T16:37:59 | null | train |
|
62,978 | nreece | 2007-10-04T12:46:17 | Microsoft Looks to Social Networking for Zune 2.0 | http://www.pcworld.com/article/id,138042-c,mp3players/article.html | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,980 | nreece | 2007-10-04T12:47:20 | At Least I Didn't Sue Apple | http://www.fool.com/investing/general/2007/10/03/at-least-i-didnt-sue-apple.aspx | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
62,982 | drm237 | 2007-10-04T12:53:24 | Overview of Paul Graham's Future of Web Apps (FOWA) session | They are probably incomplete and may contain mistakes, though I do my best to be accurate. Chances are I'll be adding links to extra material and photos later on, so don't hesitate to come back and check.<p>steph-note: missed the beginning, very incomplete... | http://climbtothestars.org/archives/2007/10/04/fowa-the-future-of-web-startups-paul-graham/ | 19 | 10 | [
62998,
63014,
62999,
63016,
63026
] | null | null | null | null | null | null | null | null | null | train |
62,996 | transburgh | 2007-10-04T13:48:19 | The Blurring Line Between Home And Business Tech | null | http://gigaom.com/2007/10/04/the-blurring-line-between-home-and-business-tech/ | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,003 | marrone | 2007-10-04T14:05:42 | Nine Steps to a Successful Online Community | http://www.kickapps.com/get-started/resources.php | 1 | 1 | [
63005
] | null | null | null | null | null | null | null | null | null | train |
|
63,004 | benhoyt | 2007-10-04T14:07:09 | Let's build a compiler (dated, but very good) | null | http://compilers.iecc.com/crenshaw/ | 15 | 2 | [
63006,
63499
] | null | null | null | null | null | null | null | null | null | train |
63,007 | tomh | 2007-10-04T14:12:38 | Ruby on Rails vs ColdFusion - Hilarious Parody Commercial | null | http://www.railsenvy.com/2007/10/3/ruby-on-rails-vs-coldfusion | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,008 | nickb | 2007-10-04T14:14:15 | The Inevitable March of Recorded Music Towards Free | null | http://www.techcrunch.com/2007/10/04/the-inevitable-march-of-recorded-music-towards-free/ | 3 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,009 | byrneseyeview | 2007-10-04T14:14:48 | The Future of Web Startups | null | http://paulgraham.com/webstartups.html | 107 | 169 | [
63033,
63027,
63032,
63082,
63053,
64912,
63140,
63658,
63076,
63161,
64173,
63123,
63315,
63587,
63494,
63409,
63250,
63083,
63188,
63154,
64765,
92803,
64356,
63178,
63756,
63233,
63111,
63455,
63454,
63041,
69512,
63270,
63198,
63050,
65134,
67263,
63194,
63482,
93187,
63472,
63100,
63770,
63968,
96789,
63119,
63051,
85496,
74858,
64426,
336686,
64467,
63181,
63821,
70722,
112883,
63183,
64003,
63269,
63333,
63018,
63275,
63128,
64918,
63672,
351148,
63179,
63054,
112884,
63073,
63175,
63562,
71072,
63316,
71445,
397934
] | null | null | no_error | The Future of Web Startups | null | null |
October 2007(This essay is derived from a keynote at FOWA in October 2007.)There's something interesting happening right now. Startups are
undergoing the same transformation that technology does when it becomes
cheaper.It's a pattern we see over and over in technology. Initially
there's some device that's very expensive and made
in small quantities. Then someone discovers how to make them cheaply;
many more get built; and as a result they can be used in new ways.Computers are a familiar example. When I was a kid, computers were
big, expensive machines built one at a time. Now they're a commodity.
Now we can stick computers in everything.This pattern is very old. Most of the turning
points in economic history are instances of it. It happened to
steel in the 1850s, and to power in the 1780s.
It happened to cloth manufacture in the thirteenth century, generating
the wealth that later brought about the Renaissance. Agriculture
itself was an instance of this pattern.Now as well as being produced by startups, this pattern
is happening to startups. It's so cheap to start web startups
that orders of magnitudes more will be started. If the pattern
holds true, that should cause dramatic changes.1. Lots of StartupsSo my first prediction about the future of web startups is pretty
straightforward: there will be a lot of them. When starting a
startup was expensive, you had to get the permission of investors
to do it. Now the only threshold is courage.Even that threshold is getting lower, as people watch others take
the plunge and survive. In the last batch of startups we funded,
we had several founders who said they'd thought of applying before,
but weren't sure and got jobs instead. It was only after hearing
reports of friends who'd done it that they decided to try it
themselves.Starting a startup is hard, but having a 9 to 5 job is hard too,
and in some ways a worse kind of hard. In a startup you have lots
of worries, but you don't have that feeling that your life is flying
by like you do in a big company. Plus in a startup you could make
much more money.As word spreads that startups work, the number may grow
to a point that would now seem surprising.We now think of it as normal to have a job at a company, but this
is the thinnest of historical veneers. Just two or three
lifetimes ago, most people in what are now called industrialized
countries lived by farming. So while it may seem surprising to
propose that large numbers of people will change the way they make
a living, it would be more surprising if they didn't.2. StandardizationWhen technology makes something dramatically cheaper, standardization
always follows. When you make things in large volumes you tend
to standardize everything that doesn't need to change.At Y Combinator we still only have four people, so we try to
standardize everything. We could hire employees, but we want to be
forced to figure out how to scale investing.We often tell startups to release a minimal version one quickly,
then let the needs of the users determine what to do
next. In essense, let the market design the product. We've
done the same thing ourselves. We think of the techniques we're
developing for dealing with large numbers of startups as like
software. Sometimes it literally is software, like
Hacker News and
our application system.One of the most important things we've been working on standardizing
are investment terms. Till now investment terms have been
individually negotiated.
This is a problem for founders, because it makes raising money
take longer and cost more in legal fees. So as well as using the
same paperwork for every deal we do, we've commissioned generic
angel paperwork that all the startups we fund can use for future
rounds.Some investors will still want to cook up their own deal terms.
Series A rounds, where you raise a million dollars or more, will
be custom deals for the forseeable future. But I think angel rounds
will start to be done mostly with standardized agreements. An angel
who wants to insert a bunch of complicated terms into the agreement
is probably not one you want anyway.3. New Attitude to AcquisitionAnother thing I see starting to get standardized is acquisitions.
As the volume of startups increases, big companies will start to
develop standardized procedures that make acquisitions little
more work than hiring someone.Google is the leader here, as in so many areas of technology. They
buy a lot of startups— more than most people realize, because they
only announce a fraction of them. And being Google, they're
figuring out how to do it efficiently.One problem they've solved is how to think about acquisitions. For
most companies, acquisitions still carry some stigma of inadequacy.
Companies do them because they have to, but there's usually some
feeling they shouldn't have to—that their own programmers should
be able to build everything they need.Google's example should cure the rest of the world of this idea.
Google has by far the best programmers of any public technology
company. If they don't have a problem doing acquisitions, the
others should have even less problem. However many Google does,
Microsoft should do ten times as many.One reason Google doesn't have a problem with acquisitions
is that they know first-hand the quality of the people they can get
that way. Larry and Sergey only started Google after making the
rounds of the search engines trying to sell their idea and finding
no takers. They've been the guys coming in to visit the big
company, so they know who might be sitting across that conference
table from them.4. Riskier Strategies are PossibleRisk is always proportionate to reward. The way to get really big
returns is to do things that seem crazy, like starting a new search
engine in 1998, or turning down a billion dollar acquisition offer.This has traditionally been a problem in venture funding. Founders
and investors have different attitudes to risk. Knowing that risk
is on average proportionate to reward, investors like risky strategies,
while founders, who don't have a big enough sample size to care
what's true on average, tend to be more conservative.If startups are easy to start, this conflict goes away, because
founders can start them younger, when it's rational to take more
risk, and can start more startups total in their careers. When
founders can do lots of startups, they can start to look at the
world in the same portfolio-optimizing way as investors. And that
means the overall amount of wealth created can be greater, because
strategies can be riskier.5. Younger, Nerdier FoundersIf startups become a cheap commodity, more people will be able to
have them, just as more people could have computers once microprocessors
made them cheap. And in particular, younger and more technical
founders will be able to start startups than could before.Back when it cost a lot to start a startup, you had to convince
investors to let you do it. And that required very different skills
from actually doing the startup. If investors were perfect judges,
the two would require exactly the same skills. But unfortunately
most investors are terrible judges. I know because I see behind
the scenes what an enormous amount of work it takes to raise money,
and the amount of selling required in an industry is always inversely
proportional to the judgement of the buyers.Fortunately, if startups get cheaper to start, there's another way
to convince investors. Instead of going to venture capitalists
with a business plan and trying to convince them to fund it, you
can get a product launched on a few tens of thousands of dollars
of seed money from us or your uncle, and approach them with a
working company instead of a plan for one. Then instead of
having to seem smooth and confident, you can just point them to
Alexa.This way of convincing investors is better suited to hackers, who
often went into technology in part because they felt uncomfortable
with the amount of fakeness required in other fields.6. Startup Hubs Will PersistIt might seem that if startups get cheap to start, it will mean the
end of startup hubs like Silicon Valley. If all you need to start
a startup is rent money, you should be able to do it anywhere.This is kind of true and kind of false. It's true that you can now
start a startup anywhere. But you have to do more with a
startup than just start it. You have to make it succeed. And that
is more likely to happen in a startup hub.I've thought a lot about this question, and it seems to me the
increasing cheapness of web startups will if anything increase the
importance of startup hubs. The value of startup hubs, like centers
for any kind of business, lies in something very old-fashioned:
face to face meetings. No technology in the immediate future will
replace walking down University Ave and running into a friend who
tells you how to fix a bug that's been bothering you all weekend,
or visiting a friend's startup down the street and ending up in a
conversation with one of their investors.The question of whether to be in a startup hub is like the question
of whether to take outside investment. The question is not whether
you need it, but whether it brings any advantage at all.
Because anything that brings an advantage will give your competitors
an advantage over you if they do it and you don't. So if you hear
someone saying "we don't need to be in Silicon Valley," that use
of the word "need" is a sign they're not even thinking about the
question right.And while startup hubs are as powerful magnets as ever, the increasing
cheapness of starting a startup means the particles they're attracting
are getting lighter. A startup now can be just a pair of 22 year
old guys. A company like that can move much more easily than one
with 10 people, half of whom have kids.We know because we make people move for Y Combinator, and it doesn't
seem to be a problem. The advantage of being able to work together
face to face for three months outweighs the inconvenience of moving.
Ask anyone who's done it.The mobility of seed-stage startups means that seed funding is a
national business. One of the most common emails we get is from
people asking if we can help them set up a local clone of Y Combinator.
But this just wouldn't work. Seed funding isn't regional, just as
big research universities aren't.Is seed funding not merely national, but international? Interesting
question. There are signs it may be. We've had an ongoing
stream of founders from outside the US, and they tend to do
particularly well, because they're all people who were so determined
to succeed that they were willing to move to another country to do
it.The more mobile startups get, the harder it would be to start new
silicon valleys. If startups are mobile, the best local talent
will go to the real Silicon Valley,
and all they'll get at the local one will be the people who didn't
have the energy to move.This is not a nationalistic idea, incidentally. It's cities that
compete, not countries. Atlanta is just as hosed as Munich.7. Better Judgement NeededIf the number of startups increases dramatically, then the people
whose job is to judge them are going to have to get better at
it. I'm thinking particularly of investors and acquirers. We now
get on the order of 1000 applications a year. What are we going
to do if we get 10,000?That's actually an alarming idea. But we'll figure out some kind
of answer. We'll have to. It will probably involve writing some
software, but fortunately we can do that.Acquirers will also have to get better at picking winners.
They generally do better than investors, because they pick
later, when there's more performance to measure. But even at the
most advanced acquirers, identifying companies to
buy is extremely ad hoc, and completing the acquisition often
involves a great deal of unneccessary friction.I think acquirers may eventually have chief acquisition officers
who will both identify good acquisitions and make the deals happen.
At the moment those two functions are separate. Promising new
startups are often discovered by developers. If someone powerful
enough wants to buy them, the deal is handed over to corp dev guys
to negotiate. It would be better if both were combined in
one group, headed by someone with a technical background and some
vision of what they wanted to accomplish. Maybe in the future big
companies will have both a VP of Engineering responsible for
technology developed in-house, and a CAO responsible for bringing
technology in from outside.At the moment, there is no one within big companies who gets in
trouble when they buy a startup for $200 million that they could
have bought earlier for $20 million. There should start to be
someone who gets in trouble for that.8. College Will ChangeIf the best hackers start their own companies after college
instead of getting jobs, that will change what happens in college.
Most of these changes will be for the better. I think the experience
of college is warped in a bad way by the expectation that afterward
you'll be judged by potential employers.One change will be in the meaning of "after
college," which will switch from when one graduates from college
to when one leaves it. If you're starting your own company, why
do you need a degree? We don't encourage people to start startups
during college, but the best founders are certainly
capable of it. Some of the most successful companies we've funded
were started by undergrads.I grew up in a time where college degrees seemed really important,
so I'm alarmed to be saying things like this, but there's nothing
magical about a degree. There's nothing that magically changes
after you take that last exam. The importance of degrees is due
solely to the administrative needs of large organizations. These
can certainly affect your life—it's hard to get into grad
school, or to get a work visa in the US, without an undergraduate
degree—but tests like this will matter less and
less.As well as mattering less whether students get degrees, it will
also start to matter less where they go to college. In a startup
you're judged by users, and they don't care where you went to
college. So in a world of startups, elite universities will play
less of a role as gatekeepers. In the US it's a national scandal
how easily children of rich parents game college admissions.
But the way this problem ultimately gets solved may not be by
reforming the universities but by going around them. We in the
technology world are used to that sort of solution: you don't beat
the incumbents; you redefine the problem to make them irrelevant.The greatest value of universities is not the brand name or perhaps
even the classes so much as the people you meet. If
it becomes common to start a startup after college, students may start
trying to maximize this. Instead of focusing on getting
internships at companies they want to work for, they may start
to focus on working with other students they want as cofounders.What students do in their classes will change too. Instead of
trying to get good grades to impress future employers, students
will try to learn things. We're talking about some pretty dramatic
changes here.9. Lots of CompetitorsIf it gets easier to start a startup, it's easier for competitors too.
That doesn't erase the advantage of
increased cheapness, however. You're not all playing a zero-sum
game. There's not some fixed number of startups that can succeed,
regardless of how many are started.In fact, I don't think there's any limit to the number of startups
that could succeed. Startups succeed by creating wealth, which is
the satisfaction of people's desires. And people's desires seem
to be effectively infinite, at least in the short term.What the increasing number of startups does mean is that you won't
be able to sit on a good idea. Other people have your idea, and
they'll be increasingly likely to do something about it.10. Faster AdvancesThere's a good side to that, at least for consumers of
technology. If people get right to work implementing ideas instead
of sitting on them, technology will evolve faster.Some kinds of innovations happen a company at a time, like the
punctuated equilibrium model of evolution. There are some kinds
of ideas that are so threatening that it's hard for big companies
even to think of them. Look at what a hard time Microsoft is
having discovering web apps. They're like a character in a movie
that everyone in the audience can see something bad is about to
happen to, but who can't see it himself. The big innovations
that happen a company at a time will obviously happen faster if
the rate of new companies increases.But in fact there will be a double speed increase. People won't
wait as long to act on new ideas, but also those ideas will
increasingly be developed within startups rather than big companies.
Which means technology will evolve faster per company as well.Big companies are just not a good place to make things happen fast.
I talked recently to a founder whose startup had been acquired by
a big company. He was a precise sort of guy, so he'd measured their
productivity before and after. He counted lines of code, which can
be a dubious measure, but in this case was meaningful because it
was the same group of programmers. He found they were one thirteenth
as productive after the acquisition.The company that bought them was not a particularly stupid one.
I think what he was measuring was mostly the cost of bigness. I
experienced this myself, and his number sounds about right. There's
something about big companies that just sucks the energy out of
you.Imagine what all that energy could do if it were put to use. There
is an enormous latent capacity in the world's hackers that most
people don't even realize is there. That's the main reason we do
Y Combinator: to let loose all this energy by making it easy for
hackers to start their own startups.A Series of TubesThe process of starting startups is currently like the plumbing in
an old house. The pipes are narrow and twisty, and there are leaks
in every joint. In the future this mess will gradually be replaced
by a single, huge pipe. The water will still have to get from A
to B, but it will get there faster and without the risk of spraying
out through some random leak.This will change a lot of things for the better. In a big, straight
pipe like that, the force of being measured by one's performance
will propagate back through the whole system. Performance is always
the ultimate test, but there are so many kinks in the plumbing now
that most people are insulated from it most of the time. So you
end up with a world in which high school students think they need
to get good grades to get into elite colleges, and college students
think they need to get good grades to impress employers, within
which the employees waste most of their time in political battles,
and from which consumers have to buy anyway because there are so
few choices. Imagine if that sequence became a big, straight pipe.
Then the effects of being measured by performance would propagate
all the way back to high school, flushing out all the arbitrary
stuff people are measured by now. That is the future of web startups.Thanks to Brian Oberkirch and Simon Willison for inviting me to
speak, and the crew at Carson Systems for making everything run smoothly. | 2024-11-08T14:21:46 | en | train |
63,010 | ACSparks | 2007-10-04T14:18:10 | Verizon to start calling and texting advertisements to customers? (pic) | Can't wait for those viagra text messages to start rolling in! A scan of the letter received is included on the page. | http://www.ajcronk.com/2007/10/04/verizon-to-start-calling-and-texting-advertisements-to-customers/ | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,011 | gibsonf1 | 2007-10-04T14:18:56 | Don't give Google double the power | null | http://www.sfgate.com/cgi-bin/article.cgi?file=/c/a/2007/10/03/EDOOSIHM5.DTL&type=tech | 2 | 1 | [
63013
] | null | null | null | null | null | null | null | null | null | train |
63,025 | luccastera | 2007-10-04T14:52:50 | In Facebook, Investing in a Theory | null | http://www.nytimes.com/2007/10/04/technology/04facebook.html?ex=1349236800&en=c704e9d70ed828b0&ei=5124&partner=permalink&exprod=permalink | 3 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,028 | mdemare | 2007-10-04T14:57:28 | Ask YC: Non-US Founders, What's Your Story? | According to pg, there's been various non-us founders who moved to the valley. So, what's your story? What challenges did you have (legal or cultural)? <p>I'm asking because I'm considering doing the same (I'm from Amsterdam). | 17 | 20 | [
63209,
63252,
63150,
63146,
63588,
63084,
63368
] | null | null | invalid_url | null | null | null | null | 2024-11-08T16:37:59 | null | train |
|
63,034 | drm237 | 2007-10-04T15:07:54 | And you know a startup is lying when they say "We are unique"! | It is apocryphally said that Benjamin Disraeli said that there were three kinds of lies X lies, damned lies and statistics. He was referring to the persuasive power of inaccurate but well presented arguments. Entrepreneurs will do well to remember this and some other obfuscatory arguments as they make their presentations to VCs. | http://www.pluggd.in/2007/10/top-entrepreneurial-lies-by-indian-startups-%E2%80%9Cwe-are-unique%E2%80%9D | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,037 | ivankirigin | 2007-10-04T15:17:02 | Remembering Sputnik: Sir Arthur C. Clarke | null | http://spectrum.ieee.org/oct07/5584 | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,039 | amichail | 2007-10-04T15:19:47 | The Paradox of Declining Female Happiness [pdf] | http://bpp.wharton.upenn.edu/betseys/papers/Paradox%20of%20declining%20female%20happiness.pdf | 11 | 7 | [
63080,
63067,
63284
] | null | null | is_pdf | null | null | null | null | 2024-11-07T07:14:21 | null | train |
|
63,042 | ivankirigin | 2007-10-04T15:22:51 | Cars Get Street Smart | null | http://spectrum.ieee.org/oct07/5577 | 3 | 9 | [
63043
] | null | null | null | null | null | null | null | null | null | train |
63,075 | transburgh | 2007-10-04T16:39:59 | Jason Calacanis Makes "The World's Greatest Coffee!" | null | http://www.centernetworks.com/jason-calacanis-web3-definition | 3 | 0 | null | null | null | timeout | null | null | null | null | 2024-11-08T04:25:11 | null | train |
63,088 | brett | 2007-10-04T16:57:39 | A VC: The Fiction of 20% | http://avc.blogs.com/a_vc/2007/10/the-fiction-of-.html | 33 | 3 | [
63444,
63136,
63901
] | null | null | null | null | null | null | null | null | null | train |
|
63,092 | far33d | 2007-10-04T17:12:36 | The Implicit Web | http://redeye.firstround.com/2007/10/the-implicit-we.html | 5 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
63,093 | michele | 2007-10-04T17:24:51 | Ruby on Rails plugin to easily perform full-text searches using MySQL | http://blog.wonsys.net/posts/26-our-first-plugin-acts_as_fulltextable/ | 8 | 5 | [
63110,
63218,
63495
] | null | null | null | null | null | null | null | null | null | train |
|
63,112 | dpapathanasiou | 2007-10-04T17:54:02 | The Microsoft Startup Accelerator Program | http://dondodge.typepad.com/the_next_big_thing/2007/10/microsoft-start.html | 10 | 9 | [
63192,
63139,
63307,
63191,
63290,
63285
] | null | null | null | null | null | null | null | null | null | train |
|
63,113 | far33d | 2007-10-04T17:54:51 | Social networking and the Geocities fallacy | http://blog.pmarca.com/2007/10/social-networki.html | 4 | 2 | [
64369
] | null | null | null | null | null | null | null | null | null | train |
|
63,121 | drm237 | 2007-10-04T18:08:00 | The ThinkGeek 8-bit Tie | A few of us monkeys at ThinkGeek had this great shared dream a few months ago. In it, the whole world was 8-Bit, just like the video games we grew up on. We found ourselves having to leap from platform to platform, to search for pieces of the Triforce of Wisdom, and to fight scary mutated plants and animals. The music was awesome (and still stuck in our heads) but the coolest part was what we were wearing: a tie. But not just any tie, an 8-Bit tie! | http://www.thinkgeek.com/apparel/hats-ties/9352/ | 2 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,133 | luccastera | 2007-10-04T18:42:42 | Email Marketer ConstantContacts Delivers Sizzling IPO | null | http://www.redherring.com/Home/22918 | 1 | 0 | null | null | null | http_404 | Page Not Found — Red Herring | null | null | Widget Spacer
Top 100
The Red Herring Top 100 awards highlights the most exciting startups from Asia, Europe and the Americas.
Learn More
Upcoming Events
Top 100 Asia
Top 100 North America
Top 100 Europe
2022 Top 100 News
2022 Red Herring Top 100 Global Submission
2019 Red Herring Top 100 Asia Winners Official Announcement
2021 Red Herring Europe Winners
2021 Red Herring Top 100 Winners Official Announcement
Most Popular
Progress Speeds Up on Dubai to Abu Dhabi UAE Hyperloop
5 Japanese Startups You Should Check Out Now
Five Top New York City VC Firms
Widget Spacer
Investment Roundup
Saudi Startup Foodics Gets $20m Cash InjectionSaudi Arabian firm Foodics, which has created an all-in-one restaurant
The Exit Report
Israel’s YL Ventures Sells Axonius Stake for $270m, Just a Week After Unicorn ValuationIsraeli venture capital fund YL Ventures has sold its stake in compatriot
Widget Spacer
Subscribe
Subscribe now to get event news and updates delivered right to your inbox:
Email*
Widget Spacer
#DigitalHerring Tweet
My Tweets
| 2024-11-08T07:34:38 | null | train |
63,134 | transburgh | 2007-10-04T18:47:40 | Healthy Community Metrics | null | http://www.centernetworks.com/important-community-metrics | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,138 | hacker64 | 2007-10-04T18:50:53 | If you're accepted to YC, can you negotiate the percentage? | I know that the amount of funding is fixed, but the percentage that YC takes doesn't seem to be. Anyone from the previous batches successfully negotiated the percentage that YC asked for? | null | 4 | 20 | [
63303,
63278,
63153,
63341,
63142,
63349,
63288
] | null | null | null | null | null | null | null | null | null | train |
63,159 | luccastera | 2007-10-04T19:26:52 | What I Learned From X That Makes Me a Better Programmer in Y | null | http://www.jeffperrin.com/index.php/2007/10/03/what-i-learned-from-x-that-makes-me-a-better-programmer-in-y/ | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,163 | tomh | 2007-10-04T19:32:23 | Here's what happiness at work looks like | http://positivesharing.com/2007/10/heres-what-happiness-at-work-looks-like/ | 3 | 3 | [
63248,
63224
] | null | null | null | null | null | null | null | null | null | train |
|
63,164 | transburgh | 2007-10-04T19:33:20 | Arrington Goes Nuts in Unnecesary Force | http://www.techcrunch.com/2007/10/04/exclusive-arrington-goes-nuts-in-unnecesary-force/ | 1 | 1 | [
63281
] | null | null | cut_off | Exclusive: Arrington Goes Nuts in "Unnecesary Force" | TechCrunch | 2007-10-04T18:32:03+00:00 | Erick Schonfeld |
11:32 AM PDT · October 4, 2007
Most Popular
Erick has been discovering and working with startups his entire professional career as a technology journalist, startup event producer, and founder. Erick is President & Founding Partner at Traction Technology Partners. He is also a co-founder of TouchCast, the leading interactive video platform, and a partner at bMuse, a startup studio in New York City. He is the former Executive Producer of the DEMO conferences and former Editor-in-Chief of TechCrunch (where he helped conceive, lead and select startups for the Disrupt conferences, among other duties). Prior to TechCrunch, which he joined as Co-Editor in 2007, Erick was Editor-at-Large for Business 2.0 magazine, and a senior writer at Fortune magazine covering technology.
At TechCrunch, he oversaw the editorial content of the site, helped to program the Disrupt conferences and CrunchUps, produced TCTV shows, and wrote daily for the blog. He joined TechCrunch as Co-Editor in 2007, and helped take it from a popular blog to a thriving media property. After founder Michael Arrington left in 2011, Schonfeld became Editor in Chief.
Prior to TechCrunch, he was Editor-at-Large for Business 2.0 magazine, where he wrote feature stories and ran their main blog, The Next Net. He also launched the online video series “The Disruptors” with CNN/Money and hosted regular panels and conferences of industry luminaries. Schonfeld started his career at Fortune magazine in 1993, where he was recognized with numerous journalism awards.
View Bio
Newsletters
Subscribe for the industry’s biggest tech news
Related
Latest in TC
| 2024-11-08T09:40:37 | en | train |
|
63,165 | transburgh | 2007-10-04T19:33:54 | Who Spams Digg the Most | null | http://www.techcrunch.com/2007/10/04/who-spams-digg-the-most/ | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,166 | transburgh | 2007-10-04T19:34:21 | Calacanis: Web 3.0 is Whatever I Say it is | null | http://www.webpronews.com/blogtalk/2007/10/04/calacanis-web-3-0-is-whatever-i-say-it-is | 1 | 0 | null | null | null | no_error | WebProNews - Digital Marketing, Technology, and Business News | null | Name |
DataAnalystPro
Ryan Gibson -
November 4, 2024
In the rapidly evolving world of technology, the role of a data analyst has become increasingly vital across industries. For those aspiring to enter this dynamic field, understandi...
SocialMediaNews
Matt Milano -
November 4, 2024
X, then Twitter, began charging developers for API access in February 2023, and has now announced a major price increase.
...
VirtualRealityTrends
Matt Milano -
November 4, 2024
Apple is reportedly delaying the launch of its cheaper Vision Pro till at least 2027, according to analyst Ming-Chi Kuo.
...
EmergingTechUpdate
Matt Milano -
November 4, 2024
Intel is backtracking on one of its most promising designs, with CEO Pat Gelsinger saying Lunar Lake was a "one-off" that the company has no intention of r...
DevNews
Matt Milano -
November 4, 2024
GitHub has released "Octoverse 2024," revealing that Python is now the most popular programming language, and AI is boosting development, not endi...
MobileDevPro
Matt Milano -
November 4, 2024
Just days after banning the iPhone 16, Indonesia has struck again, this time banning Google's Pixel fines for similar reasons as its ban on the iPhone....
Business
Matt Milano -
November 4, 2024
The Securities and Exchange Commission announced that JPMorgan has been fined $151 million to resolve multiple issues in which the company violated the law...
AutoRevolution
Matt Milano -
November 3, 2024
Hyundai revealed the Initium, a hydrogen fuel cell vehicle that represents the culmination of nearly three decades of the company's research.
...
SocialMediaNews
Matt Milano -
November 3, 2024
Reddit reported its third-quarter earnings, revealing that it turned a profit for the first time in its 19-year history.
...
AIDeveloper
Matt Milano -
November 3, 2024
In a Reddit AMA with OpenAI’s Sam Altman, Kevin Weil, Srinivas Narayanan, and Mark Chen, Altman blamed compute scaling for the lack of newer AI models....
CloudPlatformPro
Matt Milano -
November 3, 2024
Microsoft CEO Satya Nadella announced the company has recruited Jay Parikh to its senior leadership team after stints as Facebook head of engineering and L...
EmailMarketingToday
Rich Ord -
November 3, 2024
In an era where inboxes are as crowded as city sidewalks, the science behind getting your emails noticed has never been more critical. The 2024 Email Mark...
Business
Matt Milano -
November 3, 2024
Washington lawmakers are growing increasingly worried about Intel's future, even weighing additional bailout options.
...
DataDrivenMarketingPro
Brian Wallace -
November 3, 2024
Businesses are dealing with “big data” - but what they really want is actionable insight from that data. These are the accompanying services of data sc...
MobileDevPro
Matt Milano -
November 2, 2024
Apple has given the MacBook Air a surprise, but welcome, upgrade, increasing the base RAM from 8 to 16GB.
...
DataAnalystPro
Ryan Gibson -
November 2, 2024
In an era marked by rapid technological advancements, the role of a data analyst is evolving at an unprecedented pace. Luke Barousse...
TransportationRevolution
Matt Milano -
November 2, 2024
Skydio, one of the leading US drone makers, announced that China has imposed sanctions on it in response to its business with Taiwan.
...
AppDevNews
Matt Milano -
November 1, 2024
Pixelmator has long been a staple for many Mac designers, and the company is now joining Apple in an effort to widen its reach and appeal.
...
DataAnalystPro
Rich Ord -
November 1, 2024
As the clock strikes 9:45 AM, Agatha Kang, a Business Intelligence Engineer at Amazon Web Services (AWS), be...
RemoteWorkingTrends
Matt Milano -
November 1, 2024
AWS employees are stepping up their efforts to reverse ...
ITProNews
Matt Milano -
November 1, 2024
Microsoft has once again delayed the rollout of its controversial Recall feature, saying it needs more time to get it right.
...
SearchNews
Matt Milano -
November 1, 2024
Google is expanding AI Overviews in Search, rolling out the feature to more than 100 countries, providing access to more than one billion users.
...
ElectricVehicleTrends
Matt Milano -
October 31, 2024
Ford is pausing production of the all-electric F-150 Lightning, the latest indication that consumer demand for EVs is cooling.
...
MobileDevPro
Matt Milano -
October 31, 2024
Google has announced major changes to Android development schedule, saying it will release a major update in Q2 instead of Q3, followed by a minor release ...
| 2024-11-08T16:23:46 | en | train |
63,170 | mqt | 2007-10-04T19:40:14 | Why Krakow Still Works for IBM | http://www.businessweek.com/globalbiz/content/sep2007/gb20070925_228125.htm | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
63,171 | transburgh | 2007-10-04T19:40:21 | Treating Your Equity Options Like Organs | null | http://www.gobignetwork.com/wil/2007/10/4/treating-your-options-like-organs/10199/view.aspx | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,172 | arooni | 2007-10-04T19:42:40 | Ask YC: Is the Bay Area Much Better than Seattle for Startups? | Long time reader, first time poster. Thanks in advance for reading this post and extra thanks if you can reply with your thoughts. <p>I'm working full time in a software company in Seattle area and will be leaving soon to work full-time on my startup. (I already have already released a prototype of my product). I'm tempted to stay in Seattle as I love it here... but my startup is my first priority, and I'm prepared to move anywhere in the world if it means I'll have a significantly higher probability of success. Finally, I'm a single founder and potentially looking for a technical co-founder... so <i>where</i> I can find this person factors in to the decision as well. <p>Questions for you:
1) For those of you who have lived in Seattle & San Francisco, how much better is SF for startups than Seattle? How do you quantify this?
2) I have a quick list of pros/cons to Seattle vs. SF below... can folks provide feedback on whether this analysis makes sense?
3) Any other thoughts on whether I should make the move or not?
4) Where is better for finding like minded entrepreneurial hackers? <p>Pro/Con for Seattle vs. SF
Seattle Pros: lower cost of living, closer access to outdoors & mountains etc..., lower cost of rent for offices, lower legal costs, less competition for top quality talent than SF (there are fewer startups in Seattle so people who want to work at them have fewer choices on where to go), monthly startup events have on the order of ~50 people or so, rains often so you're more likely to sit inside coding than going outside
Cons: rains a lot :P<p>SF Pros: epicenter of startups, monthly startup events (SFBeta etc..) have on the order of ~100 people, huge talent pool of highly skilled engineers, more likely to find technical co-founder, more startup events, more access to capital, closer to family
SF Cons: higher cost of living, higher cost of rent, higher cost of services (leagal etc..), harder to get top quality talent (you're competing with hundreds of startups), more competition for capital<p>PS:
I have already read PG's essays and read the YCNews forums on where to be for a tech startup. I've also recently read Marc Andreessen's post on where your startup should be (he reccomends moving to the Valley). Finally, I have a friend who recently quit Google to work on his startup full time in the Bay Area and he extols the advantages of the location. | null | 11 | 25 | [
63291,
63417,
63299,
63365,
63381,
63339,
63392,
63569,
63501,
63174,
63577,
63557,
63295
] | null | null | null | null | null | null | null | null | null | train |
63,173 | nextmoveone | 2007-10-04T19:47:55 | Ask YC: 120 Words or more? | I'd like to know, what happens if your answers are over 120 words, are they cut off? less likely to be read? not read for not following directions?<p>We've got a very long answer to one question but the rest are all under 120 words. | 5 | 11 | [
63186,
63245,
63203,
63259
] | null | null | invalid_url | null | null | null | null | 2024-11-08T16:37:59 | null | train |
|
63,205 | mqt | 2007-10-04T21:19:30 | Understanding MP3 compression | http://arstechnica.com/articles/paedia/the-audiofile-understanding-mp3-compression.ars | 6 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
63,206 | mattculbreth | 2007-10-04T21:19:55 | October SmugMug API Contest - Win an iPhone | http://blogs.smugmug.com/don/2007/10/04/october-smugmug-api-contest-win-an-iphone/ | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
63,207 | mqt | 2007-10-04T21:20:37 | To CHANGE-CLASS or not to CHANGE-CLASS | http://xach.livejournal.com/138978.html | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
63,215 | transburgh | 2007-10-04T21:32:03 | Microsoft: Open-source trap or sign of weakness? | null | http://valleywag.com/tech/microsoft/open+source-trap-or-sign-of-weakness-307209.php | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,225 | nickb | 2007-10-04T21:51:35 | Craigslist Meets WallStreet...Classic | null | http://howardlindzon.com/?p=2725 | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
63,227 | bootload | 2007-10-04T21:57:47 | Techmeme is officially a cesspool | http://www.scripting.com/stories/2007/10/04/techmemeIsOfficiallyACessp.html | 4 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
63,228 | bootload | 2007-10-04T21:59:19 | Web 3.0, the *official* definition | http://www.calacanis.com/2007/10/03/web-3-0-the-official-definition/ | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
63,229 | bootload | 2007-10-04T22:00:55 | Internet Explorer 7 Update | http://blogs.msdn.com/ie/archive/2007/10/04/internet-explorer-7-update.aspx | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
|
63,230 | bootload | 2007-10-04T22:02:09 | In Facebook, Investing in a Theory | http://www.nytimes.com/2007/10/04/technology/04facebook.html?_r=1&ex=1349236800&en=73863a9e3390d63d&ei=5088&partner=rssnyt&emc=rss&oref=slogin | 1 | 0 | null | null | null | null | null | null | null | null | null | null | train |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.