Since 1986 - Covering the Fastest Computers in the World and the People Who Run Them

Language Flags
April 26, 2010

Cloud’s New Language Set to Bloom

Nicole Hemsoth

MIT’s Technology Review provided some in-depth coverage on the top ten emerging technologies for the coming year. On a list that includes solar fuel, green concrete, and light-trapping photovoltaics, the publication tacked on the concept of “cloud programming” — a revolutionary movement that is a attributed in large part to the work of Joseph Hellerstein and his team at the University of California, Berkeley.

Hellerstein and other researchers at Berkeley have created a language called “Bloom,” which has received a great deal of attention following its implementation in Hadoop. Hellerstein was able to make key alterations to Hadoop to render it less likely to hit critical points of failure and simplify scheduling processes among other unique “quick fixes.” The special ingredient in this language that makes it so functional and useful is simplicity — it casts aside the need to program around dependencies and unknowns, allowing for innovation and creativity versus what amounts to educated guesswork for programmers. While it’s not clear what immediate life-altering changes will be evident in HPC and enterprise computing upon the release date, the Bloom language is making cloud programming far more intuitive and applicable for a community far larger than a cluster of specialized infrastructure engineers. By removing the complex barriers to cloud programming, there is no end in sight for new developments for cloud-specific platforms. The language will be released in full later in 2010, but it is already gathering great interest from cloud infrastructure providers, among others.

As the MIT Technology Review describes, since prior to Hellerstein’s work, languages processed data in static batches, but they were unable to process data that was changing in real-time. Hellerstein’s “fix” for this problem is “to build into the language the notion that data can be dynamic, changing as it’s being processed. This sense of time enables a program to make provisions for data that might be arriving later — or never.”

Writing cloud applications is nothing short of a programming nightmare, even for the most experienced programmers. This is due to the fact that managing and tracking data across time is filled with such a host of unknowns that it can be nearly impossible to do accurately. Furthermore, since the miniscule errors that threaten programming tasks are difficult to detect (let alone repeat and debug), the process of writing cloud applications is thwarted at worst and messy at best.

Hellerstein’s idea is geared at finding a way to tidy the programming process by altering the database programming languages so they can be easily unified and the focus can be on creativity and innovation versus the time-consuming task of mere data tracking.

The following is a transcript from HPC in the Cloud’s interview with Joseph Hellerstein:

HPCc: Can you give some background on the Boom and Bloom project — how the idea developed, how long ago you started working on the language?

Joseph Hellerstein: This project began about eight years ago when we were spending time looking at some of the simple infrastructure involved in Internet search (which included Web crawlers and  Google’s PageRank algorithm for ranking pages to give better answers) and we noticed that in both cases, the algorithms they were using looked a lot like walking along a graph — the Web is like a graph of Web pages that are connected to one another and the crawler will follow the links and “walk” around on a network or graph of nodes. The page rank algorithm for ranking walks the same sort of graph but in its own particular way. Both of these algorithms were things that in classic logic language anyway, you could easily write in a few lines. So back in 2003 we were wondering why a programmer should have to work so hard to build these when they could be written so simply. With this in mind we set out to build an infrastructure so that a basic three-line program could achieve those goals and perform those tasks.

We did some initial things with that concept. For instance, we built a deep Web crawler, a crawler for the Gnutella P2P file-sharing network — and when we done we realized that what we were doing was actually a lot like routing on a network; that what a web crawler does is it moves its attention from node to node on the internet something like a packet as it is sent from node to node on the internet from a source to a destination.

After thinking about this, we wondered if it would be possible for us to implement TCP/IP in the same way we implemented these crawlers and use very simple logic programs. The more we thought about it, the more excited we got because the answer to that was yes, as we started thinking, we got excited because a lot of the basic protocol routing on the internet and wireless networks could be set at a much higher level in these logic languages. From then on, we set ourselves to task of building a system and language to let people build network protocols.

So all of this takes us to close to the beginning of the new century when we were doing a lot of work with what we called declarative networking, which make it easy for people to build network protocols. And when we hit this point, we had this really cool language for people who built plumbing for the internet but for these folks who already like how they’ve been doing things, there just wasn’t a lot of demand. So we were at a point in the research where we had this really great idea but the application domain it was developed for either isn’t that interesting or those who could make use of it aren’t interested.

At about this time that we had this developed and weren’t seeing a lot of uptake on the idea, cloud computing started getting a lot attention and at some point, collectively really, a light bulb went off as we realized that cloud is the perfect environment — that we needed an easier way to program things that would go across lots of different computers. And everybody needed this, not just a select group of infrastructure engineers. Cloud computing is where we saw a critical need for a programming paradigm shift.

HPCc: So this new language was not driven by a specific need or to answer to the problem of programming difficulty across large numbers of computers — it evolved on its own?

Hellerstein: No, it took on a life of its own, but actually, to back up a bit, it is a nice story about research and long-term payoff.

The roots of this go back to the 70s and 80s in database theory — back in the 70s there were some early papers saying that we should be able to program with simple mathematical logic, with just writing down rules of inference — of course, this was considered to be something of a curiosity. From this, there was a language called Prolog, which had some brief excitement and the database community picked it up in a theoretical context and developed a cleaner language called DataLog. There was a lot of controversy surrounding all of this because the theorists were wring about the esoteric principles behind this and the applied people in the field, some of whom were very influential, were telling them it was useless and had no utility — they said this in print. The applied folks and theorists — there was some bad blood there.

In early 200 when we were playing with crawlers and routing we thought that stuff might be useful in practice. Coincidentally, at the same time, a bunch of other groups in different research areas (security, complier analysis, natural language processing) started picking up DataLog and started to revive this esoteric language. In short, we’re part of the payoff of work that went on when I was in high school and college.

HPCc: What major problems does this language solve for programmers and what will it mean for large-scale computing in the cloud?

Hellerstein: First of all, the hard part about programming multiple computers at once arguably boils down to the interweaving of actions in time across the different computers since they’re all working at the same time. A second part of the problem has to do with the fact that people’s versions of data are often different across different machines.

We can put this problem in the form of a simple analogy: You can imagine writing down a recipe you want someone to cook. If you know it’s going to be a single cook you write down the order of operations and it works fine. But you take that same recipe to a commercial kitchen at a hotel and break down the pieces of the recipe and assign them to sets of different chefs, the coordination is a little different. You need to make sure each step is complete at the right time to be handed off to the next chef and that the coordination from one step to the next works. When you do things this way — have multiple “chefs” it just becomes a more complicated problem.

So to bring it back to the concept at hand, when people think about programming a thousand computers they write a single program that when run it a thousand times. When you do this, you just hope the interweavings of the actions it takes work out right — reasoning it out is very tricky because you can’t control the speed every computer runs at, or at which the messages travel to communicate and coordinate and can’t control the possibility that some of them will crash in the middle. Programming around these eventualities is really hard — even great programmers find this hard. Debugging these is also hard because the problem might be based on very subtle errors that cannot be reproduced.

The other half of the problem has to do with data and the dependencies between different versions of data. If it’s looking at a copy of some piece of data and another machine is looking at a different copy of the piece they might come to different conclusions and take different actions. It’s worse than just copied data — if it’s dependency-related, it’s not that there are different copies — there are results of different copies, which leads to a mangled final product.

To put it simply, our what our work is trying to do is start with the data itself and get people to talk about what should happen to the data step-by-step through a program without ever having them specify at all how many machines are involved. So, when you ask a query of a database you describe what data you want — not how to get it. There’s a database engine underneath that gives the “how” and that database engine has built-in operations that can deal with the tasks of query processing in a parallel fashion.

Query processing tasks are easy to parallelize — they rip apart the data into pieces and operate on the pieces independently. If we can get people to specify what the program should produce versus how it should do it, the system underneath will take care of the details. All the system underneath needs to do is partition data the way that a database query processor does.

HPCc: Can you describe how the Bloom language worked in a test project like the Hadoop modifications you made?

Hellerstein: Our work on Hadoop is not unlike the first things we did with crawlers; we looked at the Hadoop system and said, “it’s not that hard — so why is it such a big piece of software?”

Conceptually what we were doing was really simple; you think it shouldn’t be hard but it’s very big software and is complex and hard to change. We wanted to show our language was real so that everyone could see it in practice. So what we did, we completely rebuilt the Hadoop file system from scratch in one of our earlier languages to show we could do it and that it was in every way compatible with the Hadoop file system. We built the api-compatible version of Hadoop then we went ahead and said “what’s the yuckiest, hardest to modify pieces of Hadoop” and extracted that — which was a scheduling piece of Map Reduce, and we went ahead and put in a scheduler implemented in our language. It worked — we showed it could be smaller, simpler, and easier to make Hadoop better so we moved forward. Our next project was to examine the single point of failure in Hadoop — the point at which everything is lost due to this one master node. We talked to IBM and found that they’d lost terabytes upon terabytes of data. So we implemented PAXOS, which is a protocol to get the computers in a distributed environment to agree with each other and this one-month change altered Hadoop for the better.

Another aspect of Hadoop we looked at involved the master node in times of need; So the master node needs more hosepower if you run out of power or memory and you have to buy another bigger one, which is a very “un-Hadoopy” thing to do. The master is the gatekeeper to scaling — we saw we could partition the work of the master across many nodes. Upon realizing this, it took us 24 hours and we were able to parallelize this across machines. This kind of dramatic increase in ability is what we wanted to show.

HPCc: Where is the most interest in this coming from right now? Who are going to be the early adopters working with this in mission-critical or HPC environments?

Hellerstein: The people we’ve been talking to the most are those who are building cloud and data infrastructure, in part because those are the applications we’ve been focusing on. So the cloud research group at Microsoft, the people at SAP — enterprise computing is a natural place to think about this taking shape first within but it’s not likely to change very fast in practice is my guess. Enterprise as an industry is conservative because of the cost of entry is high.  The whole market moves slow — so even though those are the natural obvious applications and adopters we think about and it could be that something very lightweight is the first thing to pick this up. The people we have looking closely are all data people — people with big data problems but whoever thought something like Twitter would become the next big thing? There’s no way to tell.

HPCc: How are we going to see this manifest down the line? How is this is going to create a “boom” in cloud computing, even if it is starting at the top slowly and trickling down?

Hellerstein: When someone presents a platform with new capabilities, you probably don’t know what people will do with it yet — it’s wide open. For instance, when mobile phones with compute power started coming out there was some talk about email on the phones and location services, but people really didn’t know how mobile phones would change application developing and what kinds of applications we’d want to run on our phones. That’s a story that’s still developing, actually. In some senses, application developers are not aware of what the next “killer app” will be but people do have the tools to create it, thus it becomes about innovation. That’s where we are with cloud right now; what will happen when people have the power of a thousand computers at their disposal for development?

We’re not starting to try to develop the killer app — we’re showing how easy we can make it to build what we know already works.  The people who really need all thousand computers at once are who we protoyped this for: infrastructure services — the cloud infrastructure providers like Google and Amazon, who need to have large-scale data export and analytics systems. We showed it’s much easier to build those things in our environment than it was originally. That leaves the door open to innovation.

To read more about Joseph Hellerstein, go to his U.C. Berkeley page that has numerous links to papers and reports on this and other subjects relevant to the HPC and cloud community.

SC14 Virtual Booth Tours

AMD SC14 video AMD Virtual Booth Tour @ SC14
Click to Play Video
Cray SC14 video Cray Virtual Booth Tour @ SC14
Click to Play Video
Datasite SC14 video DataSite and RedLine @ SC14
Click to Play Video
HP SC14 video HP Virtual Booth Tour @ SC14
Click to Play Video
IBM DCS3860 and Elastic Storage @ SC14 video IBM DCS3860 and Elastic Storage @ SC14
Click to Play Video
IBM Flash Storage
@ SC14 video IBM Flash Storage @ SC14  
Click to Play Video
IBM Platform @ SC14 video IBM Platform @ SC14
Click to Play Video
IBM Power Big Data SC14 video IBM Power Big Data @ SC14
Click to Play Video
Intel SC14 video Intel Virtual Booth Tour @ SC14
Click to Play Video
Lenovo SC14 video Lenovo Virtual Booth Tour @ SC14
Click to Play Video
Mellanox SC14 video Mellanox Virtual Booth Tour @ SC14
Click to Play Video
Panasas SC14 video Panasas Virtual Booth Tour @ SC14
Click to Play Video
Quanta SC14 video Quanta Virtual Booth Tour @ SC14
Click to Play Video
Seagate SC14 video Seagate Virtual Booth Tour @ SC14
Click to Play Video
Supermicro SC14 video Supermicro Virtual Booth Tour @ SC14
Click to Play Video