Slashdot Mirror

← Back to Stories (view on slashdot.org)

How Do You Manage a Product Based on Linux?

Posted by ryuzaki0 on from the penguins-in-your-products dept.

Ryan writes "Following my advice, my company has decided to base it's new appliance on Linux. So far, it's worked out great. Linux gave us a huge jumpstart on development because of it's open nature and the information we've garnered from public mailing lists. We've added software, modified startup files, and have built our own kernel. Now the question is: How do you manage it all? Do you put it all in CVS or Subversion? Do you use the distro's packaging system (we're using Debian)? What does your build system look like?"

25 of 72 comments (clear)

  1. If this is really the question by Anonymous+MadCoe · · Score: 4, Insightful

    You really should be stopping and look at what you are doing. How you want to manage it should be part of the strategy, and actually should have been part of deciding to use Linux (not in detail, but strategically).

    So my advice, hold on, sit down and look at what you expect to produce and what you would need to get there. From there you can find out what you would need.

    You will probably run into some issues, but that's just what happens, there is no ideal situation.

  2. I don't understand the question by Anonymous Coward · · Score: 5, Insightful

    You're building a whole new appliance, but your software engineers don't know how to manage a development process?

    I mean... I'm not being nasty here, but you're in trouble, and I don't even know where anybody could start to give you advice. It would be one thing if you were looking for guidance on a regular small scale software project, but if you're jumping in feet first with a whole new large scale application and no idea how to guide the process...

    1. Re:I don't understand the question by arivanov · · Score: 3, Interesting

      A round of applause...

      While I understand your spleen and I even applaud it, there are a few things which you are missing.

      In many settings the initial people with the idea are not capable of software process management (and nearly always incapable of support process management). On top of that the people who they initially hire are usually of the "implement at any cost breaking all rules". That works great up to a prototype and sometimes even slightly later. In fact this "break all rules" culture is a model which most successfull startups in the industry have followed.

      After that, once the prototype is up and working and the initial euforia has settled in, the company comes to a point where it needs to grow up. The initial people who have ideas and who are of the "implement at any cost" variety must either move into positions where they do not prolong the company growing pains or leave. The company also needs to hire people (or less likely - find within its ranks) who are capable of long term software development process management. These are the people who must become the team leaders and managers in order for the company to be successful.

      Unfortunately, very few companies make it through this stage. Most promote the "implement by any means necessary" or the "initial idea" people into positions where they cannot cope as their mentality is incompatible with the actual requirements. They become increasingly frustrated with the mere fact that there is a process, break it all the times and explain to people who follow it that they are tails that wag the dog. In addition to that they blow any long term planning to hell and gone all the time and push the company into an endless spiral of firefighting crisis management. This all becomes a big mess and it all goes to hell sooner or later.

      Anyway, it is not so uncommon for a successful initial stage startup to have no culture of software development process and especially customer support process. In fact that is to be expected, as to get through the initial hurdles you sometimes need to walk on the dead bodies of the rules and processes that have been broken.

      Frankly, the ask-slashdotter should be applauded that they have realised that they lack this process. Now he will definitely do not like the answer to his question. It is very simple: hire someone who does and swallow the fact that you will hate him to the point where some of the veterans may have to leave. Tools like subversion, clearcase, CVS, MKS, Bugzilla do not make a process. They implement a process defined by a human. What is needed is the person who has defined the process to have a long term view as well as a view of how the process fits with support, business and the rest of the company. If he does not - no tool will help. There is nothing worse then short-termism in process definition and tool selection forced by short-termism. It will come to bite you in the arse again, and again, and again.

      --
      Baker's Law: Misery no longer loves company. Nowadays it insists on it
      http://www.sigsegv.cx/
    2. Re:I don't understand the question by Gr8Apes · · Score: 2, Informative

      Well written.

      To the OP, here's what I've personally seen: a large company with no processes in place doing ad hoc builds on local dev's machines with random tools going straight to production. This was replaced with a build machine and ant with much reluctance, as several developers had their own "job security" babies, as they were mysteriously the only ones that could build certain components, at least until the build machine became the only source of move to production code. However, the business went from ad-hoc builds to weekly builds. Yep - that's weekly builds. 72 hours for dev, 24 hours for UAT and functional testing, 48 hours for QA, then hand-off to ops for migration to production. Every week. Add up those hours and you'll understand why almost no one will work there that's been there.

      --
      The cesspool just got a check and balance.
  3. Absolutely by Anonymous Coward · · Score: 2, Insightful

    You should definitely put your code under some kind of revision control. We currently use cvs but are looking at switching to git or mercurial. One thing thats nice about cvs is the import feature that lets you bring in new copies of the open source programs you've modified and migrate your changes forward into the new copy. With regards to the packaging, its definitely worth the effort to put them into the distro's packaging system. We use debian as well and its nice to be able to have a repository that customers can just apt-get from to get the lastest for their appliance. We also have debian source packages to make it easy for the customers to get access to the source in a way thats easy for them to make changes and create new debian packages.

  4. Version Control by bigattichouse · · Score: 3, Insightful

    Your build should be in some sort of Versioning system (CVS, whatever). SOMETHING that allows you to cover your butt with you `rm` that folder and realize you just tanked the whole thing. Somehow you should be able to rebuild any version of your project back to day 1.

    --
    meh
    1. Re:Version Control by RAMMS+EIN · · Score: 3, Insightful

      And you should know who introduced a certain change, and how they motivated that.

      --
      Please correct me if I got my facts wrong.
  5. Re:depends on the scope of the project by LiENUS · · Score: 3, Insightful

    Actually even with 1 developer SVN or CVS are huge benefits, what if that developer introduces a bug? with subversion you can go through and look to see when that bug was introduced and roll it back. You'd be hard pressed to roll it back with just tarballs.

  6. Reproducability by danpat · · Score: 5, Informative

    If you're releasing a product to the public, the one word you need to keep in the back of your mind at all times is "reproducability".
    Can you, at any point in the future, reproduce whatever version it is that customer X is having trouble with?

    There are many ways to do this, ranging from taking complete snapshots of each "build" (requires lots of space, but fast to reproduce), to keeping a short list of the Debian packages installed (not much space, but slower to reproduce). It's a classic space-vs-time tradeoff.

    I'd suggest you attempt to automate the system build as much as you can. Use virtualization tools like VMWare to help perform "builds" of your OS images. Most Linux distros have automated install processes. RedHat has "kickstart", Debian has "fai" (http://www.informatik.uni-koeln.de/fai/). At the minimum, you should version control the script you use to build your vmaware images, and the configuration script for fai/kickstart. This should let you re-build everything at some later stage.

    When it comes to customising Debian systems, customised Debian packages are the way to go. If you're adding new files, package them up and deploy them as part of the automated install. If you're customising existing packages, edit their source and rebuild them with
    customised version numbers, and list those versions of the packages in your fai script. You'll need to go through the whole version control process with each customised package too. (i.e. check it's source into a version control tool, tag it, apply your changes, tag it again, then build your .deb file). You can provide "answers" files for debconf so that no questions are asked during installation, and you can tweak various settings as you go along. If you've taken the VMWare approach, you can always login to the image and make final adjustments (just make sure they're scripted and version controlled) after the Debian install is complete.

    Do a search for "customized debian", there are quite a few people doing similar things already.

    Basically, make sure that the end product requires nothing more than a button push to produce. Anything less and you'll introduce the risk of someone forgetting to perform a step, or doing it wrong. That'll create a support nightmare down the track.

    If you can reproduce easily what your customer has, you can also easily make a minimally invasive fix for them. That'll make them happy :-)

    If you're looking for resources on this stuff in general, "configuration mangement" (http://en.wikipedia.org/wiki/Configuration_manage ment) is what you want to search for. Librarianship for software systems, kind of dry and boring, but oh-so-necessary.

    1. Re:Reproducability by Mr.+Jaggers · · Score: 2, Interesting

      (to the parent)
      Agreed, reproducability is key. Not only for your customers, but just for releases in general (your QA guys love you if you can deliver builds to them and actually know which build you gave them by the time they're done testing it). Also, having stuff wrapped in deb (or, I suppose rpm) packages is really nice too, as it makes field-upgrades a snap (even on embedded appliances, provided you have a deliver mechanism), and again, your QA guys will love you if they don't have to wait for a whole new build to test out a fix; just pass them a handful of debs that you rolled on your own dev machine (source deltas checked in, of course).

      (to the OP)
      Just make sure all of your build constituents are under version control (subversion is *fine*, really... you probably want to stay away from CVS, they are different, trust me). That should include all source files, all config files, all make files, all make automation scripts, and even any notes you kept while setting the damn thing up. The worst problem I've seen in source control/build automation is magic files that do magic things (not so much fun when hardware fails). Even if it requires some manual process to deploy some of the build scripts from the source tree to a build slave, at least there is a central point from which to collaboratively edit them.

      FAI is bad news, big time. It's complicated and frustrating. If you want to customise and deploy Debian on servers, then it's probably what you want, however. FAI is really good for a server or desktop deployment environment, like, for example, if you had a standard corporate server platform, or standard corporate desktop. You use your FAI rig to clone out machines, and when you upgrade certain debs, you just remotely command your already deployed machines to 'apt-get upgrade' (or better yet, feed 'apt-get install' a programmatically-tailored & delivered list of packages). You can use 'apt-get dist-upgrade' too, but you'd really need a deep understanding of the dependency tree and you'd need to make a new 'distro' release so that apt knows what it's upgrading too (not to mention field-updating the sources.list). It's a non-trivial problem, but the tools will do it, and once it's set up, you have a single point of maintainance and control for the machines you're managing.

      For the poster's particular appliance, something like FAI or "kickstart" may not be what you need. In my last position (also embedded Debian, custom kernel, custom glibc, etc) installation wasn't simply slipping a FAI cd into the cdrom drive (there *was* no cdrom drive... embedded appliance, remember?). We actually had a flash device and had our own flash burn tool. In addition, our device had custom FPGA bits (on Xilinx chips), so we actually built the tools themselves out of source control, as well as the FPGA bits, and then used the tools to write the filesystem to the flash via the bootloader we wrote into the FPGA code.

      We built our install tree using debootstrap and a custom package list (which I think FAI would have used anyway, IIRC), and then trucked the debootstrap'ed directory tree on to the flash using a binary of the tool that was built. So, our build actually consisted of more than just the flash filesystem, it was a snapshot of all the associated tools as well. I definitely suggest investing in both source control and a RAID machine big enough to store snapshots (svn branching and tagging is the de facto way to associate a particular build with it's source files, frozen in time). That way (and I promise this will happen) when you are nearing a release, and the feature list just grew, and you can't quite get there by your delivery date, you can backport your last few weeks of bugfixes to the release branch (which you've already tagged), from which you can produce a release build.

      Certainly store any release snapshots, but I'd suggest also keeping any snapshots you pass on to your QA department. If you don't have a QA dept., then you should choose an approximate time interval and keep the b

      --

      When I grow up, I want to have Christopher Walken hair.
  7. Development, or Distribution? by KillerBob · · Score: 3, Insightful

    For distribution to the end-user, you will definitely want a package of some kind. I'm assuming that your end users won't be able to log in with a prompt, but may have some kind of web-based management, right? If you distribute your upgrades/patches as .deb packages (maybe renamed to .bin since that's what users have been conditionned to expect), then it makes things a whole lot easier... among other things, it would facilitate downloading the upgrade from a location other than where the product is: not all users have Internet connections at home, even in this day and age. You may also want to look into implementing something like Slackpackages, since they ignore dependancy. (They're basically just a tarball... you can install them manually by unzipping/tarring the file from / and then looking in the /install directory and manually executing any scripts there)

    For actual development... you're gonna *need* to use SubVersion or CVS. Cover your ass. Also, not having it makes managing a project a royal pain in the ass.

    --
    If you believe everything you read, you'd better not read. - Japanese proverb
  8. I am not an embedded devices development manager by Ramses0 · · Score: 4, Interesting

    ...but if you're using Debian, I would highly recommend that you spend a quality week or two *READING* the wonderful documentation debian has and read / ask a few questions on their mailing lists.

    Once you understand the package-management system of the SOFTWARE YOU ARE BASING YOUR BUSINESS OFF OF, the answer to your question will become clear... nay- simple.

      - MyCompanySoftware-1_0.deb, MyCompanyKernel-1_0.deb, MyCompanyOtherStuff-1_0.deb

      - Generous use of depends, requires, conflicts, provides, etc. (or maybe up-rev eg: kernel-image-2.6.8-1.deb to kernel-image-2.6.8-1-MyCompany-1.deb, these are the things you can ask for advice on Debian / Ubuntu lists).

      - Source control all files used in any of those *.deb packages, and make an automated build process that can take your source-control tree and generate your packages at any time of the day or night.

      - Set up internal repositories, ie: http://apt.mycompany.com/stable/ .../testing/ .../nightly/, etc. and integrate that with your testing / deployment infrastucture. ...but most of all, please READ the documentation that Debian has put together. In few words, it allows mostly volunteers in their spare time to do exactly what you are trying to do and with a high degree of reliability. The documentation in Debian Policy is the first stop (and most likely the last) for almost anything you are trying to do. When you see the types of bug-reports that are filed against packages that go against policy (ie: incorrect depends, provides, etc) you will see what types of mistakes are possible, and you should seriously consider how to check the work that you've done to make it more likely that your work would not have the same types of bugs filed against it.

    --Robert

  9. Re:depends on the scope of the project by krumms · · Score: 3, Insightful

    No no no no no. :)

    Whether you're working in a team or working by yourself: Use Subversion Anyway. Or svk. Or Darcs. Any reputable revision control system will kick the pants out of any ad-hoc solution you come up with. Revision control should be automatic and easy. The value of being able to easily merge changesets alone is reason enough for any non-trivial project. Keeping track of branches for experimental/delicate changes, tagging releases, LOG MESSAGES for all your changes - all of these things, use them, learn to love them. It's a bitch to get in the habit, but when you do it's absolutely worth it.

    It's taken me over seven years to truly learn the worth of version control. These days I'd dare not live without it. It really is that good. Honest!

  10. Conary/RPath by SWroclawski · · Score: 2, Interesting

    I don't work for them and haven't used their product much, but there's a company called R-Path (founded by former Red Hat early employees) that seems like its designed for "appliances" just like yours.

    The idea is that you build your platform on thier system, then you add your programs on top. The system merges updates from them and your system and places it onto the target system. The system they've built is called Conary. Conary itself is Free Software, but RPath sells services along with it that seem attractive.

    It looks very well put together and if I were looking at building an appliance, it's certainly something I'd be considering.

    http://www.rpath.com

  11. Our situation by Basje · · Score: 5, Interesting

    I work for an ASP. We've got a web application (built with Perl), running on Debian. At the moment we've about 15 servers (some dedicated to one large customer, some with over 50 customers) live, have 4 full time developers on the product, 15 people in total, and are quite succesful in our niche.

    This is the short version of how we do things.

    * We looked for an ISP where we rent the servers. They administer the servers (Debian stable), and install the perl modules, apache, etc. We don't have (want) root access to these machines: the ISP is responsible for the stability, and they do a good job. We ask them for changes/additional perl modules to be installed when needed. We've less than satisfactory experiences with several ISPs, make sure you find a good one.
    * For a repository we use cvs. This is flexible enough for our needs, and there was some experience with the app. If you haven't got any experience with cvs, also take a look at subversion or mercurial, as you could benefit from the improvements there.
    * As a cvs client we use eclipse. Great product, but unfortunately it is Java, and therefore slow. Some of the developers use the editor of eclipse, others use external editors (vi baby :)
    * Our work environment is mixed. We all have a windows workstation, but for the actual development we have a server with a dedicated debian VPS for each developer. We connect to the VPS (which is hosted on our lan, and not accessible externally) through ssh, samba and x. The VPS are UML based, but nowadays when setting things up, we'd probably use Xen. The advantage of using VPSs is that it's easy to set up a clean developement/test environment.
    * Have a release cycle, and try to stick with it. Most bugs are introduced when improperly tested code is implemented on live servers. Never edit directly on a live machine.

    Our current shortcomings (i.e. pitfalls):
    * Hardly any automated testing, and no formal testing procedures. Testing the application takes a lot of work, so it is often skimped. This is a risk, and introduced bugs are occasionnally missed.
    * The release policy is not always honored due to deadlines. This puts a strain on the organisation, because, as noted above, it needs to be tested manually. This is when testing is skipped most of the times, and most bugs are introduced. It's a commercial tradeoff: let a customer wait, or take the risk. Depending on who and when you ask you get different answers.

    --
    the pun is mightier than the sword
  12. use debian packaging by coyote-san · · Score: 2, Informative

    I would definitely put everything you do into Debian packages -- nothing should be done on testing and production systems by hand and the package manager provides a known good framework. There's a bit of a learning curve on how to produce Debian packages, but I believe there are some 'hardening' packages that can be used as models for how to handle the type of sysadmin tasks you're looking at.

    You're using make-kpkg to build your kernel, of course, so it's already kicking out packages for your locally-built kernels. ... you are using make-kpkg, right?

    I have to agree with the others that the fact that you're asking about version control tools is scary. That's something that should have been decided a long time ago.

    --
    For every complex problem there is an answer that is clear, simple, and wrong. -- H L Mencken
  13. Now that's Insightful by dereference · · Score: 2, Informative

    No points today, and I loathe "mod parent up" postings, but that's the perfect response.

    Nobody is going to be able to provide any reasonable advice, other than perhaps for the submitter to hire a consultant (or employee) that has proven experience in large scale software development projects.

    To submitter Ryan: This is highly non-trivial; you don't seem to have any idea how very much you're missing. If you don't know what you don't know, you need outside help. And because you've already started down the path without a plan, you need help fast. Very fast.

    1. Re:Now that's Insightful by torpor · · Score: 4, Insightful

      What part of "How do You Manage a Product Based on Linux?" do you not understand?

      He's not asking for help .. he's interested in the ways /.'ers are maintaining their linux-based products, perhaps (naively) hoping that the peanut gallery might provide an interesting result. This does not necessarily mean he wants help with his lame system; read closely, and you might realize that Ryan seems quite happy with his approach so far .. but this is still an interesting topic worth objective attention. Its not a screaming/crying/spoiled-brat cry for help that some of the similarly inclined responses have implied, anyway ..

      Me, I've been building linux-based systems for my own use since the days of the minix-list (and before that, RISCOS distimages). My current approach is quite simple, old-fashioned, but workable nevertheless. I simply apply the following general guide-lines for sysbuilding: complete source-control (using SVN/whatever-the-package-maintainer-uses), avoid cross-compiling, build everything on-board, one Makefile to tie together whatever components are required (linux-kernel/base-image/sysbins/libs/my_app), 'cscope -R' at the root tree when something needs to be worked out, and set it all up so that you can just type 'make' and watch the bootable .img form .. Fortunately the more you do this, the less you need to worry about package maintenance, but of course if the 'final deliverable' is a simple, plain sysimage containing all software onboard required for your embedded app, then package maintenance isn't such an issue. Its kind of fun to have a "single-image deliverable" too ..

      --
      ; -- the corruption of government starts with its secrets. a truly free people keep no secrets. --
  14. Control the platform versions by anomaly · · Score: 2, Informative

    One important point not yet raised is that you need to control the platform for your appliance. Every customer should be on a release of your code, tested and deployed on a release of the platform - hardware as well as OS configuration.

    Security and features patches are helpful, but can also bring complexity and confusion when it comes to troubleshooting.

    Your best bet is to tweak a build of the OS (shut down unneeded services, automatic updates, etc) then GHOST (or equivalent) the disk so that EVERY customer gets the same thing.

    If you choose to rev the hardware or the OS, how will you make sure that your installed base has the same stuff? I can't emphasize enough how important this is to long-term support.

    You'll need to consider how to slipstream patches in (connection to your website, flash drive, CD, etc) for both the OS and your code.

    You'll need to design it so that you can upgrade the OS install without affecting your application (perhaps a separate filesystem?) What will happen after your customer has installed and used your application for 12 months and you decide to upgrade your code? Do they have customizations? Will your upgrade work?

    Hope these ideas help.

    Regards,
    Anomaly

    --
    But Herr Heisenberg, how does the electron know when I'm looking?
  15. Re:depends on the scope of the project by idontgno · · Score: 2, Insightful

    What you're really saying, is "use version control discipline", hypothetically independent of the tool. That's the real point, one I've seen made elsewhere in this topic. The submitter is asking for tools, but really I think he's asking for process advice.

    The tool won't make you do the smart things you talk about--tagging, change tracking, etc. Every tool can be circumvented, pencil-whipped, or otherwise reduced to "going through the motions".

    The real advice here: come up with your project management goals and philosophy, then decide on methods and select tools to support those goals and philosophy.

    That said, I've used and liked subversion myself. But the temptation to bypass the onerous parts of the process is always there. We developers are a lazy bunch, aren't we?

    --
    Welcome to the Panopticon. Used to be a prison, now it's your home.
  16. PXE by anomaly · · Score: 2, Interesting

    Does your PXE process automatically partition/format the disk with the OS?

    I used PXE boot on Linux a few years ago with great success, but when I was considering doing an appliance-type solution, I created a customized system rescue CD which included a .tar.gz of each filesystem.

    This would have allowed me to script the partitioning process, as well as the extraction of the filesystems to end up with a bootable CD which would create an appliance hands-free. (At least that is what I was on target to complete when the project was cancelled by management.) Our original goal was to be able to distribute the media to a remote location and have unskilled people create applicances from commodity hardware.

    Theoretically the same thing could be done with a PXE and a boot menu. Is that what you've done?

    Regards,
    Anomaly

    --
    But Herr Heisenberg, how does the electron know when I'm looking?
  17. Some ideas.... by charlesnw · · Score: 2, Informative

    I have written extensively on this problem at my Blog. I use Morphix which is a system for building live cd's. They provide a core and you build on top of it. I have lightly modified the core (with a custom kernel and custom modules). Then you create a main module (which is just an xml file of debian packages). Morphix tools work out all the dependiences etc. I do all of my development in VmWare as it gives me a separate process space/machine to do all my work in. I will be presenting on it this Saturday at the Cerroitos Lug and the SFVLUG. It will be recorded and I will put the (video)podcast online. Along with notes and configs. Its mostly on VmWare but also how I am using it for development work. Feel free to reply to this post with questions and I will be more then happy to answer them. So vmware+morphix(highly customized) = great results. I am also building an appliance (an exchange replacement with MAPI support). See my signature for links.

    --
    Charles Wyble System Engineer
  18. Insightful my foot! by Monchanger · · Score: 2, Interesting
    So my advice, hold on, sit down and look at what you expect to produce and what you would need to get there ... You will probably run into some issues...
    What the hell kind of advice is that?

    Why didn't you just say "STFU and RTFM!!!!!!!!1" ('1' intended) and get back to your <sarcasm>thrilling</sarcasm> life? People come here, ask a serious question that's troubling them, and once they make it past the editorial interest filter, they get this bull. This isn't just one more stupid forum, this is Slashdot.

    What examples can you provide of these "some issues" you're talking about? The asker is trying to understand the whole process, and you're just telling him to expect trouble? What a worthless comment!
    1. Re:Insightful my foot! by Anonymous Coward · · Score: 2, Funny
      This isn't just one more stupid forum

      That's right! This is THE stupid forum!

    2. Re:Insightful my foot! by Wudbaer · · Score: 2, Funny

      The problem is that the original asker is trying to understand the process when halfway through without apparently having spent too much thought on the basics of what he or she is doing. "I am trying to travel from London to New York. Now sitting here at a crossroads in Hongkong I would like to know if I should have turned left in Dover or right. Do you think I should aquire a map ?"

      So trouble seems likely, I'm afraid.