Everyone understands how Microsoft makes money, but very few understand why they’re getting a wonderful operating system like Ubuntu free of cost. I’ve tried to explain it here.

The problem with opensource software is simple. The “vegetable vendor” model that most closed-source software uses fails with opensource. Take the most popular and simplest example: RedHat. It essentially creates two operating systems from the same codebase: RHEL and Fedora. They sell support for RHEL to corporates, while giving away Fedora to the community, and sponsoring its development. Make no mistake: RHEL is opensource as well, but it has no community like Fedora does. RedHat decides what to go into RHEL, and they build it themselves. Anyone else is free to build it for themselves ofcourse, but they don’t support those builds [1].

Why bother with Fedora at all? Simple. The first thing a RedHat service engineer does when he gets a complaint from a customer: attempt to replicate the bug on Fedora. If the bug’s fixed in Fedora, fixing it in RHEL is as simple as backporting the changes. If it isn’t, they’ll file a bug in Fedora. Depending on the situation, either they’ll get the bug fixed free-of-cost by the community, or will have to fix it themselves. In other words, they’re just getting code from the community free of cost by maintaining Fedora. Then why not give Fedora to the customers? Because bleeding-edge development takes place on it, and stuff often tends to break and get fixed at a later date [2]: RedHat cannot control what gets committed to Fedora, but they will make sure that only mature features get into RHEL. This service model not only applies to complete distributions, but to individual software packages as well- PostgreSQL, MySQL, Django are just a few examples.

So finally, who writes Fedora? The Fedora Board consists of nine members: five of whom are RedHat employees and four of whom are community members [3]. A lot of mainstream opensource software has a similar distribution of paid/ community developers.

Another famous model is the dual-licensing model followed by MySQL AB (now acquired by Sun). They give away MySQL community edition for free, but their enterprise edition is proprietary [4]. The advantage of having these two editions is similar to the one RedHat gains from having RHEL and Fedora. A similar approach is followed by OpenOffice.org: Their proprietary product that earns them revenue is called StarOffice. Advertising is yet another way: Google pays Mozilla for example.

So, the final question remains: apart from the corporates, who is this “community” that writes the code that end-users get free of cost? Most free software projects started out as “pet projects” with little monetary incentive. The Linux kernel was written by a student as a personal project, and several parts of the GNU operating system was written by Stallman in an attempt to create a free operating system- both were individuals who weren’t concentrating on revenue at that time. Things have changed a LOT since then. While there are still many tiny pet projects that are developed by a few people for little/ no monetary incentive, majority of the contribution to mainstream software such as Linux is from people with monetary incentive. The corporates these people work for benefit either directly or indirectly from that opensource project. Corporates that provide support for these opensource projects, that build their products on top of these opensource products, and those that simply use these products in their everyday work. Simple example: Google finds a bug in Chrome, and finds out that the underlying reason is WebKit. After fixing WebKit, getting that fix merged into upstream will benefit them, because they’re not the only people developing it. Same reason Google will contribute to SSH: They’re using it, and they’re not the only ones developing it.

Even non-monetary incentive doesn’t mean no incentive. Contributing to opensource is a great way to secure one’s future. All the work is out there in the public for everyone to see, and you don’t have to explain the work you did behind the closed doors of a large corporation in flowery language. Code talks. Everything else is CV-noise.

The whole model is sustainable in my opinion. A large corporate uses several bits and pieces of opensource software to create a product. They create an opensource project to drive it, and appoint some developers to head the project. I’ve already discussed how they’ll make money to drive it. Students and other prospective employees start contributing to the project for no monetary incentive, with the intention of rising higher in the project’s hierarchy. They’re essentially making themselves employable by the company- once the company recognizes some brilliant developers, it starts paying them and giving them specific tasks. An additional bonus kicks in when other companies also become interested in the project and start paying more developers to develop it. There’s always some ratio of developers working for monetary benefit to those working their way up.

1. Why do RedHat, IBM, and Novell contribute so much to the Linux kernel? Is it because they care about the free software philosophy and are being charitable? To quote the Linux Foundation August 2009 issue, “Over 70% of all kernel development is demonstrably done by developers who are being paid for their work” and “None of these companies are supporting Linux development as an act of charity; in each case, these companies find that improving the kernel helps them to be more competitive in their markets”
2. Why does Google pump money into a competing against Firefox with an open source alternative, Chrome? To quote an excerpt from their December 2009 blog post, “Today’s open source goes far beyond the “patent pooling” of the early auto manufacturers, and has led to the development of the sophisticated software components — Linux, Apache, SSH, and others — upon which Google is built”
3. Why are several of Microsoft’s products losing market share? Why does Microsoft feel threatened by Linux? To quote Ballmer, “Linux is a cancer that attaches itself in an intellectual property sense to everything it touches”. Is it because the general public is convinced by the GNU philosophy to “share with thy neighbor”, or is it simply because of competition?
4. And finally, a slightly off-topic question to reinforce my point. Why did Apple finally make the move to x86 even after their innumerable claims that PPC is better? Is it because PPC is inherently inferior to Intel’s x86, and nothing could have been done to save it?

All this points to one thing: Open source is an infrastructure. Just like the roads in the city that automobile manufacturers are interested in, software companies want access to existing infrastructure to build their own products upon and make money, instead of having to re-invent the wheel everytime. It’s a win-win situation for all companies. Paying Microsoft to get Windows to support their products can be an expensive affair. So making an operating system a commodity is in everyone’s interests (well, except Microsoft’s). The web browser is another example of a commodity today. Everyone’s interested in a good, conformant, open platform on which to develop their web applications on.

There are commodities in other sectors too. Apple moved to x86 because it was the standard commodity to use. Too many companies pumped money into it resulting in its development, and mass manufacturing brought down costs. Apple understood this- one company pumping money into PPC cannot match the rest of the world pumping money into x86.

The day a product comes out, every other company tries to clone it and make the product a commodity. In the small time window between the product being niche and the product becoming a commodity, there is money to be made. Take Netscape’s example: Once they felt the pressure of the competing web browsers, they realized that keeping their browser closed and exclusively pumping money into it was pointless. So they opened it out, and started the Mozilla project. In other words, open sourcing a piece of software typically means that that piece of software can no longer make money as a traditional product anymore. Same reason Facebook open-sourced many of its components: It has everything to gain, nothing to lose. It’s already too big on the social networking front to worry about competition there.

Largely, there are two ways to make money off this infrastructure: sell the cars that use these roads most sensibly, or follow a “pure service” model. The problem with the pure service model is that only RedHat and a few other companies have been successful at it. The argument “I created it, so I can service it best” doesn’t hold anymore- too many people have technical expertise in open source software. So unless your service is the cheapest and the best, it’ll be killed off by other service providers.

Products don’t have to start off being closed and then open up when they stop making money. Companies are also interested in starting off free software projects. Google Chrome for example. They wanted to make this web browser a commodity, a commodity created by them. They’ll have a foot at the door when Chrome gains larger market share.

haskell-internals.pdf (504 KB)

unladen-swallow.pdf (644 KB)

A couple of my talks have been shortlisted, but the abstracts won’t be up on the site until a week before the conference. So here are the abstracts. I’ve just started preparing the talks, so feedback is appreciated.

An Insight into CPython Compiler Design

The objective of this talk is to give the audience an insight into compiler design, specifically the design of the CPython compiler. The talk attempts to do this by taking apart the Unladen Swallow codebase.

Starting from a small hand-waving discussion using block diagrams, we will discuss compiler optimization techniques introduced by Unladen Swallow using revision control to playback changes. There is (and will be) no original research; only implementation of ideas from existing research papers.

A significant portion of the talk will be dedicated to compiling Python bytecode to LLVM IR (in Python/llvm_compile.cc), and the eval loop (in Python/eval.cc). While there are thousands of possible optimizations, only those which yield significant benefits and are in line with CPython’s objectives will be discussed.

Intended audience: Programmers interested in understanding (and ultimately contributing to) compiler projects like Clojure, Unladen Swallow, GHC.

Prerequisites: Requires a basic understanding of language grammers and parsing [1], as well as elementary compiler design [2]. The talk will jump right into the codebase with little introductory material, so the audience is required to do a little background reading.

[1] Flip through the relevant parts of the Dragon Book
[2] Scheme’s eval-apply loop from SICP should do fine

Haskell Internals

The session will focus on writing clever code in non-monadic Haskell, by solving several problems modeled on problems in [http://projecteuler.net] and [code.google.com/codejam/]. It will serve as an introduction to folds, maps, laziness, lexical closures, and other core features of functional programming in Haskell, while also attempt to give a small peek into the working of the Glasgow Haskell Compiler.

Target audience: People interested in functional programming and people interested in scientific computing.

Prerequisites: Ideally none. But since  the session intends to have little introductory material, a quick read through some jargon will be necessary.

Case study- humans went from forming small tribes that fend for themselves (and killing other tribes when necessary), to this complex socio-political structure we have today. In what direction has humanity as a whole moved? Certainly not ensuring longevity, otherwise we wouldn’t be developing nuclear warheads when people are dying of malaria in Uganda. No. It has moved in the direction that gives individuals more time to utilize their minds. Humans went from constantly worrying about the next meal as hunter-gatherers, to having a little more leisure time as farmers, to what they are today.

Humans live in complex societies today. Everyone doesn’t have to worry about what pesticides they should use to ensure the survival of the rice crop for their next meal. Individuals are different, and the purpose of society at large is to foster individual growth, while providing them convenient access to generations of human thought. It’s a delicate system though. If the society allows too much individuality, many human minds will be engaged in crashing airplanes into the WTC, and taking other human life. At the same time, if it allows too little individual growth, the purpose of humanity at large will be lost, and the society will collapse. Initially, laws and social norms were conservative, and with time, they laws become more liberal to accept a larger diversity in individuals. I’m not sure this trade-off argument works: for a significantly lower number of terrorists, thinkers like Socrates had to be put to death. No. Without those laws/ social norms, Socrates would have probably spent more time worrying about being killed by terrorists, and less time thinking about politics. Society constantly revises laws; like the ones on abortion, capital punishment, and gay marriage. Humanity still has a long way to go, and much of the progress depends on fixing things like the morality of stem cell research, for example.

There are no inborn laws or morals in humans, as several religious texts seem to indicate. Morals are defined by society after several experiments. On the right to equality for example, one school of thought gains acceptance, and all the others die out. Right to equality then becomes fundamental to every society, societies start experimenting with other issues, and the process continues. Why not just get someone to write laws of the future (read: big religious book) and enforce them? Consider the thought experiment: Would humans in 30 BC have been able to accept the right to equality? No. Laws are just a reflection of human progress.

Start off at the top level: the evaluator (Python/cevel.c). It executes Python bytecode. From the Python program you write to the Python bytecode that is produced, there are several stages with optimizations at every stage. It goes like this:


1. Using the SPARK parser generator, generate the Parse Tree from the Python code  (Parser/pgen.c)
2. Convert the Parse Tree into an Abstract Syntax Tree (Python/ast.c)
3. Transform the AST into a Control Flow Graph. Several compiler optimizations like removing unreachable code are implemented here (Python/compile.c)
4. Post-order DFS the CFG and flatten it to emit the final Python bytecode. The bytecode is then subjected to various peephole optimizations (Python/compile.c)
5. Instead of having to go through this this long procedure everytime we want to run the same program, the Python bytecode produced is stored in a .pyc file.

Enough warming up. The Unladen Swallow developers want to optimize CPython very smoothly, preferably without breaking any existing code. Their Project Plan is laid out on the Wiki page; I’ll mainly discuss 2009Q2.

If they work at any stage higher than the Python bytecode, they’ll have to re-implement the fantastic peephole optimizations written by the community over the years. The plan is simple: instead of executing the high-level bytecode in the eval loop (which can be painfully slow), compile atleast some part of it into a lower representation that can be executed faster. Why not compile all of it to x86 assembly? Firstly, we’d lose the interactive shell, a very major part of Python. Secondly, we’d lose out on Python’s high portability, that arises because it’s not tied down to any single architecture’s assembly language (I even run Python on my phone using the PyS60 package). Thirdly, it’s terribly difficult to do, makes Python uglier and unmaintainable, and it’s utterly pointless- we’re trading off too much for execution speed.

Just-in-time (JIT) compilation is the solution. Compile the code only when needed. Then again, don’t compile everything; compile when the new execution time is less than the old execution time by an extent enough to justify the compile time. Otherwise, the startup delay will become unbearable and the interactive interpreter won’t really be interactive anymore. The perfect low-level platform independent representation to JIT to is LLVM (Low-level virtual machine). So, the Unladen Swallow developers first wrote a compiler from Python bytecode to LLVM IR from scratch (Python/llvm_compile.cc). The LLVM IR (Intermediate Representation) looks a lot like assembly, except that it’s architecture-independent,  and can be subject to a nice set of optimizations. Then they modified the eval loop to execute LLVM IR, while keeping the existing Python bytecode evaluator (file renamed: Python/eval.cc).

Q3 and Q4 aren’t updated on the Wiki page, but it should be easy enough to find out the work in progress from the IRC channel, mailing list, and repository commits.

Guidelines:

1. Teach programming, and not the programming language. Discuss abstract ideas in class, and ask students to write implementations in a language of their choice. Avoid building language-specific patterns (for example, the double-for loop for generating prime numbers in C got stuck in my head). Discuss various different implementations AFTER the students have tried it themselves.
2. Discussions should span several programming paradigms. Initially, cast problem statements to strongly indicate a paradigm. For example “Go over numbers from 1 to 10 and print those that are even” versus “Define an even number and print even numbers <= 10″. Later, let students figure it out themselves.
3. Develop a hacker mindset- give students incomplete solutions written by other students and ask them to complete it.
4. For routine assignments, prepare a huge problem set of ascending difficulty to randomly pick from, along the lines of Project Euler. Problems should cover algorithms, pure math, computational geometry, and dynamic programming.
5. Conduct collaborative programming sessions where students learn to implement from each other. No single instructor will be able to provide such a vast variety of implementations.
6. Prepare a reading list for software engineering, including articles on editing (introduction to specialized editors such as Vim and Emacs), debugging, versioning, testing, and profiling. It’s important to make students write large programs collaboratively in steps, so that they will be able to appreciate the importance of these tools.
7. Prepare another reading list for theoretical computer science. Also give students sneak peeks into the latest work in every field. The purpose of this exercise is to get students excited, so that they can work independently to eventually discover their research interests.
8. Finally, it all boils down to grading. If you’re going to ask students to evaluate things like (i++) + (++i) in the exam, it’s clear that you’re expecting students to know programming language intricacies, and not programming methodology.

lecture1.pdf (130 KB)

curve-fitting.pdf (168 KB)

I delivered a talk on curve fitting today in the physics department seminar room. This is the presentation I used. The objective of the talk was to familiarize everyone with the chi-square distribution and chi-square fitting without focusing too much on the implementation details. Since the complete audience didn’t have background knowledge of probability theory, I had to briefly touch up some concepts like Cumulative Distribution Function and Probability Density Function.

Overall, I think the talk came out alright, although it was apparent that some of my fundamentals were holed. It’s a miracle it even came out, considering that I was delivering it on a paracetamol-suppressed headache and fever.

Finally, LaTeX + Beamer is too awesome!

Edits: The zeroth central moment is one, not zero.

Over five years ago, I realized that using editors like nano and Gedit wouldn’t suffice. The need to learn a real editor arose as I wrote more and more code. By nature, I’m a minimalist. I hate clicky flashy bloated things like GNOME, KDE, Compiz, Beryl etc. Emacs is large, graphical and consumes eons of memory compared to Vim. I had also just learnt touch typing and was eager to put that knowledge to use. Emacs didn’t appeal to me at all with its complex META and CONTROL keybindings and its complicated GUI. Vim, on the other hand was small, simple, ran off my terminal and had very simple keybindings. I took to Vim immediately and progressed to become very good at it. Vim uses muscle memory heavily- once you’re that good at Vim, you don’t have to conciosly edit anything; fingers move on their own and it feels like Vim is reading your thoughts. It’s the principle concept as touch typing. Which is what makes it so hard to switch. It struck me that there was something about Emacs worth learning over a year ago, but I was never really able to use it.

I wanted to do so much more with Vim when I realized that it was crippled. Everyone seemed to be talking about those features being present in Emacs. Consider a simple task- editing a file over the network. In the Vim world, I’d ssh into the remote machine and copy my ~/.vimrc and ~/.vim over, praying that the same version of Vim is present on the remote machine. Then using screen (see GNU screen) sessions, I could resume work. In the development front, I learnt that Vim had lots of features hardcoded for C/ C++, but not other languages. In Python, I had to use indentation-based folding to select codeblocks. I wished that Vim behaved more intelligently and do context-specific tasks. A :make in C or C++ is not the same as the :make in Python or :make in LaTeX. Vim didn’t understand this.

Writing and debugging were also separated- I couldn’t really debug anything from within Vim. This wasn’t critical until I ventured out to learn a Lisp. In Common Lisp, writing code and debugging it are so closely related that it was impossible to keep switching between applications to do it. Everyone recommended SLIME (Superior Lisp Interaction Mode for Emacs). I tried to switch retaining the keybindings using tricks like Viper mode for Emacs, but to be honest, nothing really worked out. Purists encouraged me to use Emacs as-it-is without these cheap tricks. I kept looking for Vim equivalents for several tasks and kept failing.

Few people understand the real difference between the two editors. They go on and on comparing the number of keystrokes required to do equivalent operations. I did the same for some time until it struck me- Vim is a dumb text editor, Emacs feels like some sort of intelligent organism. No real equivalents like the Vim “vawy…p” existed in Emacs- why? because Emacs is more intelligent in that. Vim doesn’t understand what a “function” or “codeblock” is. It simply understands characters and lines. Vim is a superb dumb text editor, but nothing more. Emacs, on the other hand, seems to understand what you write and assists you more intelligently. It doesn’t require the basic text editing functions that Vim has at all. I’ll give you an example. Recently, M-z or zap-to-char function was introduced into Emacs. Initially, I was very excited about it, because majority of my commands in Vim were dt, df. Now, I rarely use the command. There’s little doubt about it- In my Vim time, I could have beaten any Emacs expert at basic text editing. Vim does it faster. Emacs doesn’t even have many of those keybindings.

Then why? Because I came to realize that programmers do a lot more than just basic text editing. Vim and Emacs assist the programmer in different ways. Vim helps the programmer save time on basic text editing functions while deserting him when he wants to do his compiling or debugging or even interact with an external application. Emacs, on the other hand, seems to understand the code and helps the programmer operate on code entities, rather than characters and lines. SLIME is easily the best development environment I have seen. Emacs interactions with external applications nicely. Even documentation is readily available within Emacs.

What gives Emacs its so-called intelligence? A major part is contributed by it minor modes. When I open a certain file, some specific minor modes get activated and keybindings invoke context-specific functions. I loved the context-specific help. In latex-mode, I could preview the document I was writing with the same keybinding that I used to compile lines in elisp-mode. The same keybindings mean different (but comprehensible and expected) things in different minor modes.

As I started using it more and more, I understood the true nature of Emacs. Emacs is actually just an elisp environment bundled with several snippets of code written in elisp. Every keybinding invokes an elisp function (ok, some are so basic that the functions are compiled in C. But there are few immutable functions like this). This allows it to be infinitely extensible. Today, there are several brilliant elisp programs like emacs-w3m, emms, eterm, rcirc etc. which allow users to do email, chat, browse the internet and do a lot more, right from within emacs. SLIME is also just an elisp application. In Vim, everything’s written in C and keybindings are hardcoded, which is what makes it rigid.

At the end of the day, I have realized that average programmers can be equally productive on both Emacs and Vim. The question is simple- do you want your editor to assist you with basic text editing or higher tasks? And as programmers become better and better at what they do, I personally feel that they require assistance with higher tasks and not basic text editing.

Being a tech based entrepreneur patent management is a crucial issue for the success of one’s start-up.
>>> Always hyphenate words when you can. It improves readability. “tech-based”
>>> Avoid usage such as “one’s xxx”. Who is being a tech-based entrepreneur? Who is the ONE?
>>> “Eats shoots and leaves” or “Eats, shoots and leaves”? There’s a comma missing in this sentence.

You have to make sure that if a company like IBM files a patent on your new software start-up, it’s not lost among the million patents floating in the sea.
>>> Who? Me? Am I the ONE?
>>> Ambiguous “it”. What? IBM or my new software startup or IBM’s patent?
>>> “the million patents floating in the sea” should be “among the millions of patents floating in the sea”

Patent attorneys cannot help you much if you have already committed mistakes initially due to lack of awareness.
>>> What? What mistakes? Lack of awareness? What should I have been aware of?

Before getting into depth of this issue, let us understand what patent means.
>>> Marvelous. You’ve started a paragraph with a sentence referring to “this issue”. What i this issue?
>>> “Let us understand”? Are you trying to have a conversation with me all of a sudden? First, you refer to me as the “one”, and then go on to say “you”. Finally “we”?

The appropriate government gives a set of exclusive and jurisdictional rights to the inventor like distribution, sale, use, export and these rights are collectively known as patent.
>>> In trying to explain to me what a patent is in the middle of your article, you have suddenly brought in some “appropriate government”.

For obtaining a patent, an invention must cover three basic criteria: Novelty, Non-obviousness and utility.
>>> “cover criteria”? More like “satisfy criteria” or “meet criteria”.

Many inventors publically disclose their invention before filing a patent and loose on the grounds of novelty.
>>> “loose”? Come on. This is a glaring mistake.

As a entrepreneur, one must know the level of disclosure to make in public before filing a patent, which parts of the invention are patentable and if it is been covered by any other prior art.
>>> Totally incoherent. I don’t understand a thing. Break it up. “As a entrepreneur, one must know
1. The level of disclosure to make in public before filing a patent
2. which parts of the invention are patentable
3. if it is been covered by any other prior art”
Putting all three into a coherent sentence requires considerable skill.

Knowledge and Intellectual property is the prime asset a start-up can have.
>>> A and B “is”? Are you confused between singular and plural?

Awareness and confidence of its protection are the skills which makes one a successful entrepreneur.
>>> “Confidence of its protection”? I’m left speechless.
>>> ONE.

One of the major challenges is to realize the value of this intellectual property, which is well depicted in Gordan V. Smith’s famous book ‘Intellectual Property: Licensing and Joint Venture Profit Strategies’.
>>> Major challenges of what? Of being an entrepreneur?

Intellectual property is actually a legal definition of ideas, inventions, artistic works and other commercially viable products created out of one’s own mental processes.
>>> Okay, I’m tired. After telling me about how IP is important to a startup, you’re finally getting around to giving me an atrocious definition of IP. “created out of one’s own mental processes” — WHAT!?

In the same sense that real estate titles and bills of sale establish ownership of tangible items, intellectual property is protected by such legal means as patents, copyrights, and trademark registrations.
>>> “protected by such legal means as” should be “protected by legal means such as”

The United States Patents and Trademarks Office (USPTO) receives over 5,000 patent applications each week and has granted over 100,000 patents annually since 1994.
>>> *sigh* … off we are again on the roller-coaster ride- yet another irrelevant tangent. Why doesn’t the article flow at all? Are the cut-outs of articles from different Wikipedia pages or something?
>>> “5,000 patent applications each week” should be “5,000 patent applications a week”. You’re not emphasizing on what it does every week, but on the number of patent applications it receives. My college fees isn’t 35,000 INR each semester. It’s 35,000 INR a semester.
>>> “and has granted over 100,000 patents annually since 1994″ TENSE! The sentence should be corrected as “The United States Patents and Trademarks Office (USPTO) receives over 5,000 patent applications a week. The organization has granted over 100,000 patents annually since 1994.”

Since then patent application and issuance rates continue to increase exponentially.
>>> Since when?

This makes patent management a crucial criteria.
>>> Criteria for what?

The main goal of patent management is obtaining and maintaining patents. This process involves various technical, legal and business skills. Identifying, developing and assessing the technology involved in a given patent naturally requires some amount of technical knowledge. Legal expertise is often beneficial, but not necessary, to complete a patent application and maintain it. Finally, maximizing the profits of the patent is the responsibility of businesses. While numerous professionals are often involved in obtaining and maintaining
patents, it is also possible for the individual inventor to do the work himself. Although, this is less likely a wise approach if the invention is complex and the potential profitability is high.
>>> Okay, I’m convinced that this paragraph has been cut out from a different article and interposed into this one, in some vague attempt to cite some examples.

Managing a portfolio of patents in your asset is very crucial and sturdy task to perform.
>>> “is very crucial and sturdy task to perform” should be “is a very crucial and sturdy task to perform”. “Crucial” and “sturdy” task? Can adjectives be more misplaced?

Best examples in patent management will be IBM generating revenue of US $ 1 billion from more than 30,000 live patents and University of California generating more than US $ 100 million from more than 3,000
patents in the year 2007.
>>> “… will be IBM generating … in the year 2007″!? IBM will be generating revenue in the year 2007? The sentence is long and incoherent, much like most of the other long sentences in the article.

As rightly said by Jackie Hutter, IP & Patent Business Strategist, “goal of building a solid patent portfolio is to make your business an attractive target for investment or acquisition by a larger company”.
>>> The first acceptable sentence in the article has to be a quote :P

Patent portfolio management includes an extensive study of patents, valuing the patents and strategies to generate revenue from patent selling and licensing.
>>> Always use Oxford commas to improve readability, especially when the sentence contains more than one “and” connector. “Apples, oranges, and bananas” as opposed to “Apples, oranges and bananas”

A recent study in the US shows that 60% of the individuals file patents in US, while corporate earn 99% of the revenue from it leaving individuals with only 1% of the pie.
>>> “the individuals”?
>>> You like the US so much as to mention in twice in the same sentence? Where else would the study be conducted on people in the US?
>>> The sentence can mean two things: 60% of individuals in the US file patents, which seems to be completely skewed to me. The other interpretation can be rephrased as “A recent study shows that of the 60% of individuals who file patents in US, corporates earn 99% of the revenue, leaving individuals with only 1% of the pie”. It’s unclear which corporates you’re talking about as well.

The situation is much worse in Asia because of lack of awareness in means to generate revenue from patents.
>>> Unnecessarily convoluted. “The situation is much worse in Asia, because people don’t know how to generate revenue from patents”

To end the note, one must always be aware about the extent of disclosure of his invention in public, constantly manage his patent portfolio and analyze the value hidden in this intangible asset and
realize the wealth that can be generated from the same.
>>> What note?
>>> Are you trying to stuff the whole article into a single sentence? Because you should have realized that it’s not possible.

Knowing all about protecting one’s intellectual property makes him awake, aware and confident to run the business.
>>> “makes him awake”. No comments.

-> Overall, an atrocious article. I’ve wasted my time even _trying_ to edit it.