Blog

blamecontractor.cropped

 
We’re back from PuppetConf, done reviewing the feedback we got there and back to work on Stack Hammer.

 

There were actually no real surprises. We hoped to put in place the foundation for a really useful product solving really important problems. That seems to have gone as planned. Stack Hammer seems able to do pretty much everything users want to do with it.

 

We also knew that we didn’t exactly know what really important problems people would want to solve with our really useful product. We’re relatively new to this particular user community, so we don’t have enough direct exposure to what bothers its members day-to-day and what they like and don’t like.

 

So we didn’t even try to include in Beta 2 much to help the user figure out how exactly to get started, because we figured it would be a waste of time. It pretty much violates every current best practice for building applications (or buildings), but it made sense to us at the time.

 

So that’s what we’re working on now. We’ll be releasing features over the next month that show you how things fit together, how to get started and make it easy to navigate around. What’s underneath won’t change very much, if at all.

 

Another thing we’ve held off on is aggressively promoting Stack Hammer to the community at large. If we aren’t there to help you get started, we’re concerned you’d just get irritated and leave. (That’s what we’d do, after all.) So no Stack Hammer spam until next month!

Nigelstackingit

 
Our first PuppeConf has come and gone. All in all, we declare it a success, with a number of key objectives achieved:
 

  • Getting several hundred attendees to wear our ridiculous t-shirts or stick our ridiculous stickers on their notebooks.
  • Getting a significant number of attendees to be photographed with their faces sticking through a ridiculous poster.
  • Giving a slick Stack Hammer demo to everyone who walked by our station with only *one* bug encountered, which Kenn skillfully worked around in all subsequent demos.
  • Verifying that that lots of people think Stack Hammer will be awesome (which we suspected but really didn’t know, because we hadn’t talked to two hundred potential users).

These were not isolated events. In fact, as our Creative Director explains to us, the site design, naming, t-shirts, stickers, cheap publicity stunts, etc. – everything plays a part in creating an edgy brand around an awesome product.
 
The biggest achievement was the fact that Kenn was able to give a few hundred Stack Hammer tours over three days with only one real bug discovered . What made this so amazing is that we entered testing a week late, lost almost another week due to GitHub API outages and other misfortunes and basically had three days to test and fix an almost completely new service.
 
Our developers write awesome product code!

old-spice-guy_sm2

John and I haven’t exactly been twiddling our thumbs while the rest of the team gets stuff working for PuppetConf. On the contrary, we’ve been spending lots of time giggling over youtube videos and coming up with clever catchphrases and double entendres.

 

It started innocently enough with a demo to show at PuppetConf. But somehow we ended up re-watching all the Old Spice Guy videos and decided we had to work that in. (We honestly can’t recall how it happened…Portland, Wieden+Kennedy, power tools…who knows?)  And then we were inspired to try our own hands at producing edgy, offensive material that would appeal to the sort of young people we’re likely to encounter at PuppetConf.

 

And before we knew it, we had probably gone too far, but printers had been paid and the presses were already humming. Having recently skimmed Dick Cheney’s memoir at Barnes & Noble, however, we did remember to build plausible deniability into the most offensive material, so we should be ok.

 

We’ll have pictures from PuppetConf for you next week.

betabeta

Remember that first beta we told you about in July? It was pretty nice, but it had a couple of gaps.

 

First, the product was called Stack Hammer, and you’re supposed to use it build software stacks. The problem was that there was nothing about stacks in the applications. There was plenty of really useful Puppet stuff, but you had to use your imagination to see the stacks. We’d definitely file that one under “shortcomings.”

 

Second, the company’s name is “Cloudsmith”, and has been since the beginning and that wasn’t an accident. Doing something with the “cloud” today is kind of like doing something on the Internet in 1999. But there was no “cloud” stuff to be seen in beta 1 either: another shortcoming.

 

We’re taking journalistic license, of course. Every witty blog post has “conceit” and this post’s conceit is to be dismissive of beta 1 when, as we already noted, it was actually pretty nice. So maybe we should just come out and say it: beta 1 was just fine, but beta 2 is an ELEVEN!

 

Pull your assets in from a GitHub repository, stack up your modules or create new ones. Put the stacks on a node. Configure a Puppet master. Validate it to make sure it’s right; graph it to visualize the dependencies and locate problems. Then deploy it all to your favorite Amazon AMI and spin it up. All from within a very slick looking Stack Hammer UI. Total eleven-ness.

 

We’ll be cutting over from beta 1 to beta 2 at the start of PuppetConf (this Thursday), and the next days will be kind of dicey. We’re finished development about a week late, which wasn’t bad given that the beta 2 cycle took up four three-week sprints.

 

But we committed to being out with beta 2 at PuppetConf, which means we have a week less for testing and tutorials etc. will have to wait until next week. We had more bugs than usual in the final sprint when we brought the front and back ends together (putting them on separate development tracks was the only way people were able to take vacations this summer). And, of course, the GitHub APIs we use became suddenly and mysteriously flaky during testing.

 

So this week’s beta will be an authentic beta, rather than the perfect, pseudo-beta that appeals to our sense of smugness. But….we do have t-shirts and stickers!

We’ve just pushed out the second major release of the Geppetto IDE for Puppet, just in time for PuppetConf in Portland next week.

 

The list of enhancements is pretty long, and lots of them were requested by early users, many of whom have been really helpful.

 

We should give a special shout-out to some of the folks at Puppet Labswho have been using it every day and giving us great feedback.

 

At this point, Geppetto is of at least 2.0 quality. If you’re a Puppet user and like an IDE-style interaction, there’s no reason not to try it.

 

If you’re going to be at PuppetConf this week, we’ll be glad to give you a tour.

your hand here

 

 

What is a beta without beta testers? Not much, of course.

 

We assume that every able-bodied Puppet user immediately started knocking out stacks when we opened the beta last week. But in case you didn’t, we’d love to have you as a beta tester.

 

All it takes is a willingness to (1) try out Stack Hammer and (2) complain to us about what you don’t like using the Feedback link. (If you’d like to tell us nice things as well, we certainly won’t object, but we’re expecting you to complain.)

 

We’re also working directly with a small number of users to identify requirements for upcoming releases. If you’d like to join this elite and highly selective group, simply email us and you’ll be promptly ushered into the inner sanctum.

 

We look forward to hearing from you.

there-will-be-blood

 

Stack Hammer Beta went live today!

 

We think the end result looks great and is a fantastic starting point for the service. On the other hand, anyone who launches a public beta without a feeling of apprehension, if not terror, for what is about to come is probably delusional.

 

As with any entrepreneurial venture, such as becoming an oil baron starting with nothing but a pick ax and a few dusty acres, getting here required a ruthless and single-minded focus, particularly on the part of Kenn Hussey and the rest of our engineering team. So hats off to them! (Whereas for “the management,” the key trait required was a zen-like combination of patience and equanimity.)

 

FYI, if you have no idea what we’re referring to with the picture and the reference to the oil business, this should help.

hammer_smash

 

It’s taken about a year, and a redo, but we’re about ready to unleash Stack Hammer on an unsuspecting public. We’re just polishing up the site, and we’ll start opening it up in a few days.

 

We’d been feeling really good about how things came together. But then came this new Thor movie. One minute, big hammers are a completely “ownable” brand, and the next they’re on billboards everywhere you look. This is not just some *coincidence* – we’ve been, like, totally ripped off. The Hollywood suits got wind of our plans, and then rushed their film out to get “first-mover” advantage.

 

The good news is that this is definitely survivable. Our market is pretty different form theirs – movies, action figures and other commercial tie-ins (them) versus web apps that help you create, share and provision software stacks (us). Once things settle down, we don’t expect to be bumping into Kenneth Branagh and his “backers” at Paramount Pictures very often.

 

And who knows, maybe we’re partly to blame? We thought we got the hammer thing from “smiths” and “smithing.” But it does look kind of *Viking-chic*. Plus, we have all these Swedes on the team. So maybe we actually ripped them off subconsciously?

 

But we digress. Back to Stack Hammer.

 

The beta actually came out a bit different than we originally anticipated. Maybe a little less *vision* on display (in this first release), but hopefully useful and easy to understand. Plus, we’ve leveraged some really good and popular technologies Puppet, GitHub/Git and Elastic Beanstalk, rather than indulging the tendency to develop everything ourselves.

 

In this first version, we focused on doing something really good for existing Puppet users. We took our notion of a stack – a set of software elements you plan to deploy together – and mapped it to Puppet constructs (manifests, modules, catalogs, etc.). Then we provided a nice visual way of developing and sharing these “Puppetized” stacks. Our intention is to be 100% complementary to Puppet, which doesn’t provide much in the way of authoring and sharing support. We rely on the Puppet runtime for provisioning, deploying, monitoring, etc. Following the provisioning hand-off, we’re out of the loop until it’s time to modify the stack.

 

All the information relating to a user’s stacks (Puppet files, metadata, social info, etc.) is versioned and stored in a Git repo. So instead of inventing a new Git hosting service, we just used GitHub. (They provide a pretty good API for third-party apps.) This makes it really easy to work with assets you keep in Git, and also lets us leverage GitHub’s great social mechanisms.

 

Many users can’t keep everything at GitHub, so we’ll eventually need to support Git repos in other places. But we think GitHub is a very cool way to get started, and it makes Stack Hammer a kind of bridge between the code you develop and the code you deploy.

 

Something that isn’t directly visible to users, but has been really good for us, is Amazon’s Elastic Beanstalk. We’d built the first version of the beta on Google AppEngine, which seemed smart until they started to go wobbly on supporting “Internet companies” like us (their term). Then when EB came out this winter, it was exactly what we needed and we were able to take a lot of we’d created for AppEngine and just apply it to EB. So far the experience has been great….it’s the future!

 

We wanted to keep the first release as simple as possible, so there’s a lot we didn’t include. One area where there’s not much to see yet is the *cloud*. This is kind of  ironic, given our name, founding vision, current fashion, the architecture of our service, etc. But we’ll be doing something about that in a release later this summer. Given our recent experience with Mr. Branagh et al., we’ll be keeping the details to ourselves until a later date.

 

Do not be fooled by cheap imitations like this. You need the real Stack Hammer.

 

The Geppetto release party is in there!

Geppetto 1.0 is released and ready for download. We want all the feedback we can get, so try it out and let us know what you think!

 

If you haven’t been following the project, Geppetto is an integrated toolset for working with Puppet modules and manifests. It’s built on the Eclipse platform. If you’re an Eclipse user, you can install it directly into your IDE. If you’re not, it’s also available as ready-to-run .zip’s with a much smaller footprint than the full Eclipse.

 

Although we’re calling it “1.0″ (actually “1.0.0″), Geppetto is is probably more mature than many 1.0 releases, and we have invested quite a bit of time in it over the last six months. (Actually, it didn’t come out of nowhere; it builds on work we’ve done in other domains over the last several years.)

 

We released the first beta at FOSDEM 2011 in Brussels in early February, and got lots of really useful feedback there and at PuppetCamp Amsterdam in April.

 

So thanks to everyone who’s offered help and encouragement along the way, with a special shout-out to the people at Puppet Labs.

berlage-by-night

We’re just back from Puppet Camp 2011 in Amsterdam. Great city and great conference. And we had a great time.
 
We were there to speak as newly minted “domain experts” in module development, meet the folks from Puppet Labs. And, last but not least, we wanted to give some early looks at Stack Hammer to attendees, and get some feedback for the public beta next month.
 
The conference was in this amazing building called the “Beurs van Berlage”, which is Dutch for a stock exchange built by a guy named “Berlage”. They built it to last at least 1000 years (ironically, it was too small and they had to move across the street after ten), so it has six foot thick internal stone walls faced with this incredible brickwork.
 
Unfortunately, those same architectural qualities make it a less than ideal place for a conference where you hope to demo a web app (such as Stack Hammer), because it was virtually impossible to get a WiFi signal in the building. That said, we did get some feedback and we were pleased with what we heard. We’ll have more on that in a few separate posts next week.
 
The talk and demo Henrik gave on module development didn’t require internet (Geppetto is a local tool) and was a big hit. (A lot of people were saying it was the best talk they heard, at least until Randall from Puppet Labs gave his talk on usability the next day.) It was both surprising and encouraging how many people are planning on using Geppetto, given that it’s only a few months old and just on the threshold of a real release.
 
Here’s the slides from Henrik’s talk; the video is below:
 

 
We also lead a breakout session on Puppet and the Cloud. The turnout was great, but the session turned out to be a bit disappointing. We really were hoping to talk about web apps/web services in the Puppet domain (hint: like Stack Hammer), but everyone else was just thinking about picking up their Puppet systems and running them over Amazon or Rackspace, or maybe even just on VMware).
 
No one had any experiences that were specific to Puppet, and there was no point in talking about blindingly obvious topics such as “what are the pros and cons of the cloud.” So the discussion never completely took off. But we did get some good data points, most importantly that it is still early in the actual adoption cycle in the EU.
 
Worth noting is that “cloud” now has a very definite meaning in users’ minds: general purpose compute infrastructure running at Amazon (or Rackspace, etc.). It *does not* include applications migrating from being on-premises to web apps or web services. So what we’re really interested in at Cloudsmith is “web apps (or SaaS) in the Puppet domain”, not “Puppet in the cloud.” This probably should have been obvious to us before the conference. But now we know.
 
Finally, we did get to spend some quality time with the Puppet Lab guys, as well as two days in Amsterdam, which alone made the trip worthwhile. Here’s a photo of us hanging out with Luke, Nigel and Randall from Puppet Labs at the end of the show outside the Beurs van Berlage, just as locals were getting started with their annual Queen’s Day partying. We were actually getting some work done, i.e. “aligning our respective visions for the future of” the Puppet Forge. FYI, this picture was snapped just before Kenn (sporting stylish new “architect glasses”) reached over and gave Randall’s beard a playful tug. (Only kidding.)
 
We’re looking forward to the next Puppet Camp.
 

Amsterdam-Red-Light-District

 

We’re off to Amsterdam for Puppet Camp. In addition to doing *platinum sponsor* stuff such as giving talks and networking, we’ll be using the event to show what we’ve been working on for the last nine months.

 

First up will be Geppetto, which we’re declaring *ready for primetime* and bumping up to version 1.0 (from 0.1). The feedback from FOSDEM was that Geppetto was of at least of 1.0 quality when we introduced it in February, and he’s been significantly enhanced since then. But going directly from 0.1 to 2.0 seemed like cheating, so it’s 1.0 for now. Henrik will be showing Geppetto off in his talk tomorrow, and we’re hoping it takes off quickly over the rest of the year.

 

The other major event will be an early look at Stack Hammer. We’ve finished the first externally presentable version of Stack Hammer, and we’re pretty excited about how it came out. Nearly everything we wanted made it into this beta “preview”, which about 90% of what we think it needs to be for a full public release. We’ll use feedback from the PuppetCamp preview to finalize the scope of the first public beta, which we hope to finish developing next month.
 

 

No trip to Amsterdam is complete without some bicycling. So, time permitting, we (most likely just the “royal we”) plan to stay in shape tooling around town on one of these fifty-kilo Dutch cargo bikes everyone back home has been buying.


 
Here’s a webcast done by James Turnbull at Puppet Labs providing a good overview of Geppetto.
 
We introduced Geppetto at FOSDEM in February. We’ll be versioning it up to 1.0 and declaring *good to go* at Puppet Camp in Amsterdam later this month.
 
So more webcasts and demos to follow over the coming weeks.

buckminster.dymaxion.car

It looks like there’s more Buckminster in our future than we thought. Buckminster was one of our most significant contributions to the Eclipse community, representing possibly 50 developer-months of work (Thomas-months, actually…) over the years.

 

Last summer, we decided that Buckminster was more or less mature. In our view, it was the best way to build Eclipse projects, whether headless or from the workspace, as well as a great solution to all sorts of other build/assembly problems. Roughly half of the projects in the Eclipse release train were built with it. And it had a healthy footprint inside Java development organizations (Eclipse doesn’t keep stats, so it was always hard to know how many).

 

We had all sorts of new ideas for simplifying the build and provisioning area with modeling and DSLs, etc., but jamming them into Buckminster didn’t make sense architecturally.

 

Plus, the Maven people were pushing a new technology (Tycho) that was important for their commercial plans. We didn’t see how it was a good use of our time, or good for the community, to get pulled into a fight with Maven partisans over what was, for us, purely a contribution to the commons.

 

So we figured that we would let the technology speak and users decide. We continued to support the user community. And we continued to use it for our own internal builds (which makes us really efficient). But in terms of focus, we more or less declared success and moved on.

 

Subsequent events confirmed our recent epiphany that sometimes (by the way, not always, just sometimes) the less you think about something the better it does. Because we woke up last week to realize that Buckminster was, if anything gaining momentum. New projects were using it (Google’s first Eclipse project, for example), and the community was pushing back on the Maven people’s assertion that Tycho has become the “new standard.”

 

So maybe we were too hasty in our pursuit of the “new.” (It wouldn’t be the first time.) It’s still true that Buckminster is mature. And we aren’t interested in a “Buckminster vs. Tycho” fight. But we will take some time to talk about how we’re using Buckminster (continuous build, GWT apps, Amazon Web Services, etc.) and help others who want to use it too.

Puppet camping

We’ll be attending our first-ever Puppet Camp in Amsterdam next month as a *Platinum Sponsor*. We’re giving talks on two areas of interest–working with Puppet modules and Puppet in the Cloud.

 

The timing of the event is particularly good, because we’ll be ready to open up the first public beta of Stack Hammer. So we’re planning on on a soft launch in parallel with the event.

 

To be honest, we’re not exactly sure what a *soft launch* means at this point except that Stack Hammer *will be* ready for public consumption and we *will* encourage everyone we speak to to use it. Stay tuned for more details soon in an upcoming post.

 

The even is shaping up really well. So if you can make it over to Amsterdam at the end of April, and you’re interested in Puppet, Stack Hammer or devops in general, we hope you can make it.

Geppetto goes to FOSDEM

Henrik was in FOSDEM over the weekend showing off Geppetto on the Configuration & Systems Management track, courtesy of the people from Puppet Labs.

 

Turnout was pretty good. What was most surprising to us was that that there was a lot more “enteprise-y java-ness” in the audience than you’d expect for a free conference of “6000 hackers” dedicated to “free and open source software”, the logo for which is a disembodied brain. Of those attending Henrik’s talk (n=80?), roughly two-thirds had jobs where they developed in Java, and the majority of those were using the Eclipse IDE. Good news for Geppetto!

 

The overall reception was positive. A number of people starting using it or logging issues issues during the conference. Feedback from the Puppet Labs folks was also really encouraging. We’ve been thinking of Geppetto as being at the “0.1” stage in terms of quality, but the feedback was that’s definitely “1.0” or greater (i.e. release quality).

 

The most puzzling occurrence was this tweet from analyst Stephen O’Grady at Red Monk. What does this mean? Could he be saying that Geppetto was the highlight of the conference for him? (Seems like a stretch.) Or was he being sarcastic and saying that the conference was narrow and dull? Or that everything was a mashup, and this was just one example? We’re not 100 percent certain, but we’ll take this a compliment until further notice from Mr. O’Grady.

 

The presentations weren’t being recorded, but here’s a link to the Henrik’s slides. We’ll turn this into a full webcast when we get a chance.

 

And thanks again to the guys from Puppet Labs for hosting us!

Working our way up

Who is this kindly looking fellow? If you guessed ‘Geppetto’, the namesake for our first major contribution to the Puppet community, you guessed right. You’re also right if you guessed ‘Geppetto’s primary author’, our own Henrik Lindberg (plus moustache).

 

We’ve been doing less open source development than we’re used to over the last six months. We’re still active at Eclipse, but it’s been more sustaining work than major initiatives. And the majority of our technical cycles this summer and fall was highly specific to Stack Hammer and not that useful to anyone else. So we were starting to feel more cut off than we like.

 

The Puppet Labs guys have made it really easy for us to jump in to their community. We thought it would take up to a year to earn our way in (that’s how it works at Eclipse), but it’s been much faster. We reached out to them in early December to say we’d been doing a lot of work with Puppet and wanted to start contributing back. As we took them through what we’re doing, they got really excited about the possibility of creating a new Puppet module editor based on Eclipse.

 

In building Stack Hammer, we needed to come up with ways of translating our model of a “stack” (i.e. a set of components stacked up into a single installable unit) into Puppet constructs such as manifests, modules, catalogs, etc. We also needed a simple web UI that lets our users create and edit these “stacks” without being exposed to the underlying Puppet machinery. The way we’ve implemented this makes it really easy to turn it into an Eclipse-based editor.

 

To be honest, we expected them to get excited about *something else*. Partly, it’s because we were forcing ourselves to work outside of our comfort zones. But it’s also because we weren’t sure how Eclipse, with all its enterprise-y java-ness, would play in the Puppet community, where everyone seemed (to us, at least) to want to work from the command line. But the Puppet guys thought this was a non-issue, and they’ve been really supportive.

 

So Geppetto is the result. For lack of a better term, Geppetto is a kind of “Puppet IDE” used to author manifests and modules and publish/consume them to/from repository such as Puppet Forge. The only similar tool available today is the Puppet Module Tool, which is fairly bare bones, as well as under-resourced (and *only* works from the command line).

 

In developing Geppetto, we got to use all the modeling and Eclipse technology/knowledge we’ve built up over the years. Geppetto’s underpinning is a model of the Puppet language, along with parsers, validators and formatters, that translate between the Puppet construct (i.e. a module) and its editable representation (i.e. the model). We’re packaging it so that it can be used as an Eclipse plug-in, standalone editor application or from a command line.

 

Working in our comfort zone definitely has its advantages. We’ve been able to put together a pretty decent first release in roughly a Henrik-month. (The hardest thing was naming it, since there aren’t that many puppet-y names available to choose from.) Plus, it’s been gratifying to see that our past work can be applied outside the traditional Eclipse community.

 

We’ll be showing Geppetto at FOSDEM in Brussels next week. Hopefully, we’ll get some good feedback, and maybe even someone to help out going forward.

On the road again

We’ve gone out of our way to fit Stack Hammer in with what our target users are already using. Where something overlapped with how we *could* have scoped Stack Hammer, we’ve cut Stack Hammer back and made it complementary. We’ve always *tried* not to reinvent the wheel/boil the ocean. But while our predecessor service was built largely open source code (a lot of that developed by us), large chunks of Stack Hammer are made up of other vendors’ products. (Not that that’s unique these days, but it’s still kind of amazing when you stop and think about it.)

 

A few technologies are worth calling out by name: Puppet, a great framework for configuring and deploying software; Git, the *new* way of managing source code, and GitHub, an amazing “social coding” service built around Git; and Amazon Web Services.

 

In the case of Puppet, we almost missed it. (Ruby types consistently described it to us as just one of several configuration/deployment tools….) Luckily, we dug into it before it was too late, saw that it was much more than that–it’s actually an incredibly capable and well architected framework for software configuration and provisioning. So we threw out the provisioning technology we’d invested some dev-months in writing redesigned Stack Hammer to use Puppet as a provision-configure-install framework.

 

In the case of GitHub, we’d always planned on using Git to version code artifacts and thought GitHub might be the best way to provide Git repos. But when we started actually using it, we came to appreciate the complete *awesomeness* of its social mechanism. So gone from Stack Hammer’s scope were its own social mechanisms (not yet developed, thankfully) and in was a mashup with GitHub.

 

And then there’s AWS. We started with Google’s AppEngine, which, together with GWT, was a really compelling story a year ago. (We were even toying with using Wave as the web client.) We quickly ran up against some major limitations with AppEngine/GWT client/server communication, but fixing that become a major contribution to the Eclipse modeling framework. (Shout-out to Ed Merks!)

 

Then Google suddenly changed course on AppEngine last fall so that you couldn’t really build a public web service on it, and we were left hanging. Once again, architecture and modeling paid off. We had separations of concern and abstractions in all the right places. Within a few weeks AppEngine was gone and AWS had replaced it.

 

Short-term, it would have been easier to just use our own technology, because we ended up throwing away over the last 12 months at least a dev-year of technology we’d just developed (or had developed several times in the past). But we’ve done that before. This is definitely better.

Going not gone

Before we “light out for the territories”, we thought we’d take a quick look back at an open source community in which we’ve spent a lot of time and learned a lot over the last several years–Eclipse.

 

We got involved in Eclipse back in 2003, long before Cloudsmith was started. We were developing Buckminster–the technology that helped put us on the road to Stack Hammer–and needed an open source community in which it could thrive. When we founded Cloudsmith, we decided to put as much of the technology we were developing into open source as we could and made a bigger bet on Eclipse. So we became strategic members and served on the board for several years, in addition to developing most of our foundational technology as open source at Eclipse.

 

To be honest, it wasn’t easy at first, since we were competing for mindshare in a community that was dominated by big companies like IBM. But it’s actually true that the community is merit-driven. Acceptance isn’t immediate, but if you have good ideas, produce good technology and are willing to contribute, you’ll earn your way in.

 

For us, the turning point was jumping into p2, Eclipse’s dependency management and provisioning framework created by a large team at IBM. Initially, it was seen as competitive with Buckminster, and to some extent it was. We pruned Buckminster in a few areas and started contributing major extensions to p2. After a few months, we were welcomed as the first active p2 committers outside IBM. (“Committer” is an Eclipse term for a core member of the project team.) And Buckminster continued to thrive.

 

Similarly, we helped the foundation automate the build of the first annual Eclipse release in 2007. By last summer, that system had evolved into the b3 aggregator, which is widely used throughout the Eclipse community, most visibly to assemble the work of roughly 500 committers and 40 separate projects into Eclipse’s official release-stream. Meanwhile, we’d spent lots of time facilitating Buckminster adoption, with over half of all active Eclipse projects (and nearly all of the roughly 30 or so modeling projects) building their contributions with Buckminster.

 

When Kenn Hussey, lead of the Model Development Tools project, joined the team full-time last year to run development (complementing Ed Merks, who’d been our “modeling guru/cons”), we added modeling to our portfolio of activities in the component build-assemble-deploy domain. This came in really handy when were looking for ways to abstract away dependencies between the server-side technologies in Stack Hammer and the GWT (Google Web Toolkit) technology we were using in our web interface. And so we ended up making major contributions to the Eclipse modeling core to support development of GWT applications and other RESTful web UIs.

 

And so after several years of hard work, which had made us kind of the “the dudes” in some really important technical domains at Eclipse, why have we been scaling back our involvement? Limited bandwidth and the need to focus, really. In order to spend more time using (and contributing to!) some new technologies, we have to cut back on the time we spend on Eclipse.

 

There’s still plenty of great Eclipse technology inside our service, and we’ll still be contributing as much as we can (i.e. still plenty) to those Eclipse technologies on which we or others depend. But to free up room to do something new, we have to cut back elsewhere.

 

Therefore, to all our past, current and future friends at Eclipse, it’s been great to meet you and has been/is/will be great to work with you! And we’re still here (maybe just a little less so).

Next

Only four in ten Americans reportedly believe in evolution. Fortunately, only one in ten Cloudsmithers is American because we’ve gone all in with evolution over here.

 

We started Cloudsmith with the goal of making it simpler and less expensive to maintain software that was assembled from open source. We’d spent a number of years thinking about how open source was changing software development. You could put systems together incredibly quickly, because there was all this great open source out there to stack. But what you ended up with was that much harder to work with, because of all the dependency issues affecting your stack. So we thought solving this would be a big step forward.

 

Our first idea (circa 2004) was to use our architectural experience to stack up open source into different supported distros. Fortunately, we never started that company. Our second idea (circa 2005) was to develop an ALM-type software system that made the process manageable. Fortunately, we never started that company either.

 

Our next idea (circa 2006-7) was to create a web service based on a big dependency map of open source. You could add in your own components, stack things up, share and reuse stacks, and deploy directly from the cloud. Over time, network effects would make the service more powerful as users built on other users’ stacks. This idea became Cloudsmith.

 

We definitely got the trend right.  When we started, the problem we were addressing was not universally recognized. Now, everything is “clouds” and “stacks” and everyone is complaining about managing their dependencies.

 

But, we also made a few mistakes. We came from the Java/Eclipse/enterprise space, and we knew that the larger the organization, the bigger the problem. Unfortunately, most of these shops were (and many still are) ambivalent about open source, the cloud, keeping information outside the firewall,etc. So we ended up developing private repositories and dealing with protracted decision-making processes, which is not what we set out to do.

 

We corrected our course last spring. Friends at two different web startups called us up within days of each other and said they were looking for a service that could manage the dependencies in their Ruby production stack.

 

As we dug deeper, we realized that while we were dealing with Java and Eclipse and banks, all these web companies were going from four to 40 developers and hitting the complex build/dependency problems we could solve. Also, unlike enterprises, they were: used to consuming web services; used open source by default; had cultures in which fast decision-making and time-to-market were key; and had no problems sharing everything that wasn’t proprietary code. In other words, there was now a market receptive to both what we were doing and how we wanted to do it.

 

So we spent the last 6 months rebuilding our web service from the bottom up. We’re calling it Stack Hammer. (Hence, the image of the guy evolving into the hammer, in case you were wondering…)  Compared to what we set out to do, Stack Hammer is an evolutionary change (more precisely, a punctuated equilibrium, and the basic idea is still the same.

 

But it’s really different in terms of the technologies it uses and how it fits into the landscape. A lot less (but still plenty) Eclipse and Java and a lot of Puppet, Git and Amazon. We’ll have more to say, when we get close to publicly launching the service this spring.

Hello there

We’ve been quiet for a while, but we’ve also been very busy. The team is the same. But basically everything else we’re doing has been getting refreshed. Technology, product, target market, brand.

 

It’s taken about nine months, and required some mid-course corrections as one of our technology partners (big guy, begins with a “G”) went wobbly and was replaced with two smaller partners (small companies beginning with “P” and “G” respectively).

 

But we’re now weeks from stepping back into daylight. We’re starting out baggage-free with a new blog, and this was the first post. More to come in our next posts.