History of Calc Solver

I’ve been trying to avoid writing a piece like this simply because if I wrote one, there would be a lot of bitterness involved, and I don’t like to put a blame on anybody. But when I saw a lot of confusion over the state of my Calc Solver in Barcelona (not the least of which is Louis’ announcement on Calc Solver for 3.0 during his keynote speech, which was truly a bad surprise for me), as well as this statement by Stefan Taxhet (st) in the issue page outlining Sun’s intention to duplicate the entire work I did (for free), I felt like it was time for me to explain what actually happened surrounding my effort to write an Optimization Solver for Calc.

Background (Why I started this)

Back when the OO.o project just started, the Calc team was requesting for two features from the community. One was advanced statistical analysis add-on, and the other was linear and non-linear optimization solver. Back then, I had already submitted more than a few bug-fix patches most of which were accepted and integrated (aside from this 2 and half year old patch which would probably never be integrated and I had already lost my hopes for) and started feeling comfortable with Calc’s code base. As the next step, I wanted to do something bigger, like a full-fledged feature, to try to prove to those Sun guys that they can count on hobbyist hackers writing a significant piece of code.

There was already some effort on writing a Solver for Calc well before I started working on my own (back in 2004). One was written in OO.o Basic (initiated by Jim Thompson), and the other was written in Java as a UNO component (Arun Gaikwad). Unfortunately Jim could not continue his work due to unavailability of spare time because of his other responsibilities (here is his last email post to sc-dev mailing list). Arun’s work was promising, but he insisted on integrating his work under GPL, which was not possible at the time because OO.o was licensed under SISSL/LGPL. The consensus back then was to convince Arun to submit his work under LGPL as an external component, which would legally permit OO.o to include it without compromising the license under which OO.o was distributed. But the effort to convince Arun failed, and we were back to square one.

During that time, I had already started my own effort on writing a Solver. My intention was to write a Solver component that would allow a clean integration into OO.o by writing one from scratch. But since I didn’t have any idea on how to write a solver, my effort started from buying books (I bought three) and studying on the subject of operations research. I didn’t want to announce it at that time simply because I didn’t even know whether I could go anywhere with this, so I worked on this in my spare time, studying the books, writing and testing the algorithms in Python (with the intention of re-writing them in C++ later), and investigating UNO’s AWT dialog framework because I didn’t want the kludge of adding a Basic layer to my component just for the dialogs.

After months of hacking, finally, the breakthrough happened. Since I felt comfortable that I could go somewhere with this effort of mine, I made an announcement on the sc-dev mailing list. Here is my first announcement on the sc-dev mailing list, and the later update. After that, I was making constant status updates in the Solver issue page as well as the sc-dev mailing list so that the world (and more importantly the Hamburg team) knows that I was working on this, to avoid duplication of effort. Everything was going reasonably well.

Google Summer of Code (GSOC) 2005

That year was the first year of Google Summer of Code. I didn’t think much about that event because I was not a student, and I didn’t think I would be involved in any way. But to my surprise, Sun decided to post the Solver task as one of the student projects, without even contacting me, despite the fact that they must have known my effort since I diligently made my update known to the public, both on the mailing list as well as the issue page. And the description of the task sounded as if the task was never touched by anyone. I was confused. I thought to myself, they could have at least contacted me how much work was already done before submitting that task to Google as if it was never touched. Because of that, I was forced to upload my interim code to the issue page to make it clear that part of the work that was planned for GSOC was already finished.

The very next day I uploaded my code, I received privately an angry email from someone who wanted to work on this task, but felt unfair because I uploaded my code to the issue page the very next day of the GSOC announcement. He was telling me how he didn’t appreciate what I did because he had just wasted 2 hours of his time writing a proposal. I felt humiliated. It was not I who decided to register that task as GSOC task, and I was not even contacted! And I am the one getting this angry email even after I put so much effort writing that code I wrote all in my spare time? Who is being unfair now!?

So, I forwarded that email to Erwin Tenhumburg, Louis Suarez Potts and Niklas Nebel, expressing my dissatisfaction on how they decided to register this task with GSOC even though the work was already on-going and they should have at least contacted me on the status of the effort. Only Erwin replied to my email. After exchanging several emails between Erwin and myself, they decided to put me as co-mentor of this GSOC task, and put Niklas as the Sun contact in case I need help from Sun. This is how I ended up mentoring the project for GSOC 2005. My memory is vague, but I believe I was the only mentor who was not a Sun employee but a free-lance hobbyist contributor that year.

But mentoring a student, totally on my own time was not very easy. I did my best, but unfortunately the project was not successful. In the end, there was no single line of code contributed from the student. Again, I don’t mean to put a blame on anyone, and if I had to pick one, I would certainly pick myself to take the blame. But it simply didn’t work out.

Post GSOC and Joining ooo-build

After the GSOC, I went back to what I was doing before the GSOC, which was to continue to improve the simplex algorithm for linear programming. At that time, there was one avid user of my Solver from Belgium (Ludvic Ansiaux), who was testing it for every version I released. He helped me sort out lots of bugs in my optimizer algorithm and some UI issues, so I have to give him a huge thank you for what he did. To this day, I have never received any help on testing as big as his.

But my progress was slowing down, and I was starting to realize the difficulty of writing a good Solver component, especially the backend optimizer code. I was simply losing my motivation because of lack of progress. But I forced myself to go on, simply because I didn’t want all of what had done to be wasted.

Then around January of 2006, Michael Meeks contacted me, telling me that he was interested in integrating my Solver code into ooo-build – the build used by Linux distributors (such as Debian, Ubuntu, SuSE) to ease the pain of integrating new code and distro-specific code into OO.o because of the upstream’s lack of interest in integrating patches. I was simply delighted, and didn’t think twice about joining them and making my Solver officially a part of ooo-build. It was also when the Solver code was morphed into a full fledged module named ‘scsolver’, after Michael reorganized my source tree to fit the OO.o build system. My excitement was back once again, and I was very delighted to see my Solver distributed in the default OO.o build that comes with openSuSE 10.1.

That’s also when I got my first software engineer position at SlickEdit after years of non-IT work in environmental science field. Unfortunately, however, this also meant that more time was spent on my new job, not because the new job required more hours but because my previous job didn’t constrain me as much in terms of work hours (in other words, I had more free time then). But I managed to go on improving the linear optimizer. In the end, however, with Michael’s suggestion, I decided to ditch my own linear optimizer in favor of using lp_solve maintained by Kjell Eikland and Peter Notebaert, and focus my effort on writing non-linear optimizer instead. That was actually the right decision because lp_solve is simply a much better optimizer than the one I wrote myself.

At that time, other Linux distributors such as Debian and Ubuntu started including my Solver, suffice it to say that brought more excitement to me.

GSOC 2006

Jody Goldberg decided to register this Solver project as a GSOC task for the year 2006, and he and I signed up as the co-mentors of this task. But unfortunately it didn’t attract any students that year, and as a consequence, there was no single line of code contributed. There was someone else from the Novell side assigned to work on this, and he did work on the code awhile as far as I can tell. But in the end there was no code either.

Then CWS was created

In September of 2006, Michael told me that it was now time to upstream the Solver code. He created a CWS for this (called scsolver02), and I began working toward putting my code into CWS. This was not an easy task, however. For one thing, I had to make the Solver related code a configure-time option (with --enable-scsolver option), which meant that I needed to find a way to make building of lpsolve and scsolver modules optional. Now, for someone who was not very familiar with OO.o’s quite convoluted, unorthodox build system, this seemed like a huge mountain of task (and it was). But I managed to find a way by looking at other optional modules and trying to make sense of it and do something similar for the lpsolve and scsolver modules.

Besides the above configure issue, I also needed to find a way to make the Solver menu item in the Tools menu optional, which as we discovered was not as easy as it seemed. But I had to solve these two issues because, obviously, without them being solved, there would be no chance of integration. So I investigated further.

I believe there was a little confusion even among Sun engineers with regard to how to implement a conditional menu item. I initially asked Eike on the sc-dev mailing list, and he referred me to the framework-dev mailing list instead. So I asked the question there, which resulted in this thread. In short, the discussion started from how to conditionally add a menu item, to how to make my Solver component a pure UNO component to make it truly an optional feature. But there was one problem: I was using the internal string resource manager API to localize the strings, but there was no UNO equivalent of string resource manager (an effort only recently included). I wasn’t really sure in which direction the discussion was going, and I don’t really remember if there was any consensus as to what the next step would be (as far as scsolver02 cws integration is concerned). But the discussion ended, and I was somewhat left confused, unsure of what to do next.

The specification woes

In addition to the above task, Michael Meeks told me (perhaps against his belief) to write a specification which he said was sadly something I needed to write in order to get my code accepted upstream. I knew how much he was against this whole specification process. Although I was not in favor of the specification process myself, I was not that much against it at the time. That said, I had no doubt in my mind that writing a specification for this Solver feature would require a fair amount of time. In the end, I accepted the task, somewhat unfavorably, in order to get things moving.

Please note that I was doing all of this completely on my own time, and no one was paying me to do any of this. I had to make a lot of sacrifice with my precious family time to allocate some time to work on this, but I was still left with only 30 minutes up to an hour of time available each day. Suffice it to say that my progress was very very slow, and since there was no coding involved, my motivation was all time low. But I kept going, believing that someday all of this would end.

Then the specification template really brought me tons of agony. Apparently there was some sort of Basic macro embedded in the template itself, to control some list boxes present in the template. It was designed to run a custom Basic macro every time the value of a list box changes. However, there was some hard-coded file path in the Basic code that prevented any of this from running properly (someone told me later that the code would only run properly inside Hamburg), so every time I changed the value of a list box, I’d get a run-time error message. Not to mention I couldn’t author the dialog description part of my specification because of that. I found myself debugging the basic code, wondering why on earth I had to debug a code when I was supposed to write up a documentation for the feature! My level of frustration was rising rapidly.

After three days of struggling with the misbehaving basic code, I asked for help, on the spec-dev mailing list. Then I soon found out that this was not a new problem and others were experiencing it as well. Two days had passed since I posted my request for help and I was still not getting any reply, so I asked again if anybody was there to comment. Still no reply from Sun. My frustration was at its peak because I was really trying to get the spec completed so that I could integrate the CWS and go back to the fun of coding again. This spec writing (debugging?) non-sense dragged me on for weeks.

Then my patience had run out, and I finally exploded. At that time, Michael was also running a piece on how the spec process was broken, in a very humorous way. So I emailed him and dumped my frustration with this whole specification process. I feel sorry that he had to listen to all my rant, but he was kind enough to listen to all of what I had to say, then after some private email talk between him and someone over at Sun, he eventually initiated this infamous specification thread. I don’t want to go into the details of the discussion we had on that thread (it’s all public for those who care), but it’s probably sufficient to say that nothing really has changed, except for the fact that now we are allowed to write a specification on the wiki, instead of using the Writer template. What I was quietly hoping to see out of this discussion was that we could finally abolish this painful specification process, but that unfortunately didn’t happen. (In retrospect, I was probably a bit too naive to have expected that from Sun. I should have known better.)

So, I was back to having to write a specification. This time on the wiki, but the same process nonetheless. After that thread had settled, I already told Michael that, after finishing the integration of the CWS, I did not want to go through the pain of upstreaming again, and that I would like to continue my work in ooo-build only. But deep down, I even had little motivation left to continue at that point, and I was more or less thinking about what I was going to say as my last word to the project, though part of myself was still wanting to stay with the project (after all, I loved hacking the OO.o code). I was torn. For the record, I tried to write a specification even under that kind of mental state, but my fingers would refuse to move, and I found myself sitting in front of my computer not doing a thing.

After joining Novell and licensing change

Long story short, I joined Novell in March 2007. I had already decided to leave the project before that, but Novell decided to pick me up. When Novell asked me whether I would be willing to change the license of the Solver code to LGPL only, I simply agreed. The change in licensing made perfect sense since the entire code was owned by myself (~99%), with a small fraction contributed from Novell and Debian, under LGPL.

But that did not mean that I lost interest in contributing the code upstream. Quite the opposite. Since it was made clear back when we were having a licensing discussion with Arun that LGPL code would be perfectly acceptable for upstream integration, I didn’t even expect that changing the license to pure LGPL would make much difference. As I said in my last comment in the issue page, my hope was to bring this functionality to all users of OO.o, but under a slightly different, more liberal license to make it fair to all the work and support those Novell guys have given me to make all of this possible. I truly believed what we were asking was a small, small favor, and I believed that we deserve at least that much after all we had done to the project.

Then Louis Suarez Potts announced Sun’s intension to develop a Solver for 3.0. I was there, witnessing his announcement on Calc Solver for 3.0 first-hand. Again, since it was never communicated with me, I was not quite sure what that announcement meant, until I saw this comment from Stefan Taxhet in the issue page.

So what happens next?

I simply don’t know, but one thing is clear. If Sun insists on rewriting all the work I’ve already done just to ensure that they own all the code in OO.o, even though it is legally permissible to integrate my code under a pure LGPL license as an external component, then perhaps I need to re-think my relationship with the project. Because that would be a clear sign that the goal of this project is no longer to work with community developers (i.e. those who contribute code, not talk) and create a vibrant open-source project where contributors feel they are making a difference, but to take advantage of free labor to further the corporate goal of Sun Microsystems, by protecting vigorously Sun’s total ownership of the code base as well as the development process in their entirety.

But I’d love to be proven wrong. I’d love to be proven that Sun still are willing to work with us, to make OO.o truly a wonderful product as well as a project attractive to prospective code contributors. But there is nothing I, as a single insignificant mere mortal can do to influence the behemoth that is Sun. It’s impossible to make an even slightest change in how the project is run, even after countless hours of coding and more than 10,000 lines of code generation (which I received no compensation for and involved quite a lot of personal sacrifice). In the end, I made no difference at all. Sad, truly sad.

39 thoughts on “History of Calc Solver”

  1. Hello Kohei!

    Sad to read your blogpost about the your way of solver intergration. I very a like the idea of solver and I am very happy with your implementation. I know the way of upstreaming is very painfull. In my opinion this holds back freelancer programmers to contribute to OOo project much more. Putting code into OOo from outside of Hamburg is near impossible. This will decrase the motivation. You pointed the last entry of this issue: http://www.openoffice.org/issues/show_bug.cgi?id=8808
    In my opinion it is nonsense. Throw away your work without any comment is unfair. I can’t see behind the scenes, but dupliucating this efforts are fancy.
    Here also I would like to offer my help – for ex. translation or other. Also I planned to integrate your work to OxygenOffice Professional.
    In fact I have some question in this theme because I do not understand what is the logic behind of this decision.

  2. This is a sad story. Sun can be just bizarre.

    What does st mean when he says, “As this seems not to be an option for you we start to implement a solution within the spreadsheet project. You are welcome to join this effort.”


    What is not an option for you? Contributing your code under LGPL? I thought you said it’s already under LGPL.


  3. Hello KAMI!

    I truly appreciate your kind words, and thanks for offering help on translation. I don’t know how long my Solver code will survive because it will eventually be killed by Sun’s own replacement. But as long as it’s alive, please feel free to use it in OxygenOffice too. I’ll try to keep the effort going as long as I can.


    Yes, my code is already LGPL, and so is OO.o’s code. What st implied when he said “As this seems not to be an option for you we start to implement a solution within the spreadsheet project.” is (probably) the fact that I opted not to assign copyright over my code to Sun so that Sun can take ownership of my code. All I was asking was to integrate my code as an external component, which allows a non-Sun owned LGPL code into OO.o code base, but they simply refused to do that and no reason was given whatsoever.

  4. Hello, Kohei, just to give you the assurance of my sympathy. I feel really bad about those times where I was trying to advocate for building developer community for OpenOffice.org. I will have to appologize to anybody that could have been mislead by me to do such a foolishness as to sign the JCA. Your story proves that Sun is hot having any problem to sacrifice developer community at the altar of their business interests. Don’t be discouraged, there are people out there believing in you.

  5. Hi Kohei,
    Well I added my own 2c to the issue. I don’t expect an answer from Sun Legal, they have never deigned to contact me on the previous occasions where I put legal and factual questions to them. It might raise an answer from someone in the development team, but I wouldn’t count on it. From my POV, this is clearly a strategy decision taken by higher management within Sun that has then filtered down through the ranks. All I can say is that duplication would clearly be a waste of valuable and scarce ressources for a project that doesn’t have too many outside developers anyway, and it is a real shame that someone somewhere has decided that once again, the best way to obtain support for your project is to kick those who support it voluntarily in the teeth. Perhaps Novell (or you, if you are still prepared to be involved) could see its way to providing the Solver code as an extension, then it would be easier for others to get hold of and install.

    Best regards, and thanks for all the effort you have put in.


  6. I am not certain that I understand:

    Sun demands LGPL and you use LGPL so no problem there.

    Sun demands JCA, and you refuse JCA (is this correct)?

    It is my understanding that with JCA, SUN can then defend violations if needed. Without JCA, then you must defend them and SUN has no legal recourse.


    Do you feel that this is this accurate?

    SUN Already has my JCA on file…

  7. I am not a great Sun fan, but to be fair copyright assignment is something that many formal bodies, including the FSF, insists on it (see http://www.fsf.org/licensing/licenses/why-assign.html). I can understand why you might want to keep a copyright on a large body of code you wrote, but insisting on reassignment to accept code for upstream integration is Sun’s prerogative, and actually a pretty sensible policy from their point of view.

  8. Mr. Yoshida,

    I’m sorry for what you have gone through. Your angst could have been avoided had Sun Microsystems carried out their earlier promise to create an independent Foundation for OpenOffice (similar to the Apache Foundation) as has noted here, excerpted:


    > The OpenOffice.org Foundation
    > Last updated 2001 November 4
    > The OpenOffice.org project currently does not have a foundation. Plans are in the works for creating such a
    > foundation. The below text was composed at the project’s birth and can serve as a proposal for the creation of
    > a foundation.
    > The OpenOffice.org project will establish the OpenOffice.org Foundation, a non-profit organization that will
    > oversee the operations, technology strategy, incorporation of technology contributions, and establishment of
    > standards in conjunction with other standards bodies and open source projects as appropriate. The intention is
    > that this foundation will be modeled after the Apache Software Foundation. A Steering Committee (or board)
    > will be established with members from the open development community and SISSL licensees. Sun
    > Microsystems will hold a minority representation in this governance structure.

    and which my colleagues and I called upon in 2002, excerpted:


    > I am calling for the formalization of the “OpenOffice Foundation.” The
    > Darwin port team needs the support and resources of the Foundation to
    > navigate the treacherous waters it faces. The Foundation is
    > mission-critical to a viable Darwin port, particularly given the current
    > alignment between Apple and Microsoft on Office X and their systematic
    > marshalling of Apple/Microsoft resources against GPL software. The
    > creation of the OpenOffice Foundation is 18 months past due, plain and
    > simple.
    > I consider it outright imprudent for Sun and “The OpenOffice Foundation
    > under Formation” to solicit contributions for the Electronic Frontier
    > Fondation at the upcoming Linux World Expo. Only a Foundation, and those
    > elected to direct the use of the resources it controls, can expend the
    > resources of a Foundation. Self-dealing (directing resources of others
    > to third-parties that certain volunteers may personally favor) is very
    > dangerous.

    Now is as good a time as ever to put pressure on Sun to finally do the right thing by setting OpenOffice free in the form of an independent Foundation that they promised over five years ago.

    Until such time, in Sun we shall *not* trust (e.g., ).

    Best regards,

    -Brendan Larson

  9. @tf:

    The FSF does indeed require copyright assignments for programs it distributes, but those assignments are much different than the JCA.
    The FSF assigment states that the FSF will always release the assigned work as free software, but the JCA makes no such claim, and basically allows Sun to fork a proprietary version whenever they feel like it.

    Excerpt from an FSF assigment I signed in 2001 for GNU Grub:

    4. FSF agrees that all distribution of the Works, or of any work “based on the Works”, or the Program as enhanced by the Works, that takes place under the control of FSF or its agents or successors, shall be on terms that explicitly and perpetually permit anyone possessing a copy of the work to which the terms apply, and possessing accurate notice of these terms, to redistribute copies of the work to anyone on the same terms. These terms shall not restrict which members of the public copies may be distributed to. These terms shall not require a member of the public to pay any royalty to FSF or to anyone else for any permitted use of the work they apply to, or to communicate with FSF or its agents or assignees in any way either when redistribution is performed or on any other occasion.

    5. FSF agrees t hat any program “based on the Works” offered to the public by FSF or its agents or assignees shall be offered in the form of machine-readable source code, in addition to any other forms of FSF’s choosing. However, FSF is free to choose at its convenience the media of distribution for machine-readable source code and may charge a fee of its choosing for copies.



  10. @ Michael FIG: Sadly OO.o is using a very old version of the contributor agreement. The current version guarantees that all contributions will be available as open source software. Hopefully OpenOffice.org will soon switch to the up-to-date version.

    @Alex: Don’t forget lawyers can only advise their own clients. Until you work for Sun you are most unlikely to get advice from Sun Legal.

    @ Kohei: The requirement for a contributor agreement existed long before you started work on Solver. Why is it a surprise that it is still a requirement in order to upstream in OpenOffice.org?

  11. Sad stories to be read (I ve been triing for long to push OOO since it was closed source StarOffice 3.xx) , does someone thinks as I do that Big Blue Freed his Lotus Simphony to solve issues such as theese, or do they just add to them_
    thanks 4 the good work on solver.

  12. Kohei,

    First of all thanks for your good work on the solver. As you say this is unpaid work and has been for the benefit of all the users of OOO. Apologies if my comments are misleading as I am a long time user of OOO, not a programmer. As a user I would want/prefer Solver as an add on or extension, not in the main codebase. Would this not get around the licensing issue? Aside from that, I understand why the solver would be better off under LGPL (i.e. third party contributions).

  13. What could have been done better was to get a group of people interested in the project early on, not necessarily programmers, that would undertake the task to promote the work within OpenOffice.org.

    There are many such “assistants” willing to help out and have otherwise “boring” work delegated to them.

  14. Man that’s really a triumph of bureaucracy over sense. Perhaps you could consider porting your Solver to KOffice? The code is much easier to work with and there are no such licensing issues there… though with all this irritation I would not be surprised if you are entirely burned out on the whole thing.

  15. Whoa. I’m used to watching what happens in real open source projects. By “real”, I mean that if you have a contribution you submit it and if some appropriate subset of the core developers think it’s good, they commit it, and everyone goes from there. This is just a leetle bit different.

    As to copyright assignment–there’s a core distinction between the FSF and a large corporation. The FSF can be trusted. A company like Sun should not be going around expecting people to trust them. For-profit corporations are responsible to stockholders and to no other stakeholders, which makes them untrustworthy by definition to those other stakeholders; if their intentions are good, they should be making sure nobody *has* to trust them.

  16. I had similar issues with Fedora Linux where there CLA (http://fedoraproject.org/wiki/Legal/Licenses/CLA) gives rights to Red Hat – and the Fedora Foundation was killed for some reasons
    It says: “You hereby grant to Red Hat, Inc., on behalf of the Project, and to recipients of software distributed by the Project: …(a) a perpetual, non-exclusive, worldwide, fully paid-up, royalty free, irrevocable copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute your Contribution and such derivative works; and,”

    So they also do not swear to Open Source everything. I think it is time to work out some good practice when it comes to those contributor agreements. The problem I see is that they tend to make live more complicated and also are additions to a license – so you license under LGPL – but you need to read the CLA too carefully, because this also defines rights. So I like to see a template like for licenses – but for contributor agreements. This should it also make easier for people to trust such an agreement instead of having to hire a lawyer for every line of code. Or as Creative Commons.org states “it can be that easy, if you skip the intermediaries”. lets do exactly that. Make contributing easier and trustworthier. — Thilo

  17. Kohei: One question I keep coming back to is this: why not just package Solver as an add-on? That way you wouldn’t have to submit it under the SCA you have already signed, since it would not be integrated back into the main trunk where that is a requirement, yet everyone using any version of OO.o would be able to benefit from it (rather than just Novell’s downstreams) and OO.o would be able to distribute it.

  18. Simon:

    I was always making my Solver component available as an add-on up until I started localizing the dialog strings. When I worked on integrating my Solver into ooo-build (that you called ‘Novell’s downstreams’ although it’s hardly just for Novell, but also for Ubuntu, Debian, Mandriva, etc.), we needed to localize the strings, and doing it via UNO API alone was not possible. So, I used OO.o’s internal string resource API to make that happen. But doing that unfortunately made it impossible to build my Solver component as a pure add-on package.

    Another issue is the ABI compatibility. All of my systems I use for hacking & development run heavily bleeding edge versions of Linux distros, and the version of gcc that those systems use are all newer than 4.1.0. But the upstream version of OO.o (for Linux) is still built using gcc 3.4.1. So for a C++ add-on to be ABI compatible with the upstream version, it needs to be built using 3.4.1. Now, I was compiling gcc 3.4.1 from source just to build my Solver add-on, when I was still making it available as an add-on from my website. But times have passed, and now it’s not simple to compile gcc 3.4.1 from the source anymore using the most recent version of gcc. Last time I tried, I was not able to build gcc 3.4.1 using gcc 4.1.2.

    But besides this, sure. I’m all for making my Solver package as an add-on. The compiler issue can be solved by using an older Linux distribution (perhaps on VM), but I’m still scratching my head about the string localization issue. I was able to hack up a link time string localization (really a bad hack, but it works!), but I’ve been getting requests for run-time localization. So, there is still some work needed. And I have to admit, just pointing people to ooo-build is much easier than going through all these hoops, just out of laziness.

  19. […] Hoy me enteré que existe una versión de OpenOffice que incluye, entre otras cosas, una función Solver como la de MS Excel. Quienes la hayan usado, saben que es muy útil, pero hasta el día de hoy no sabía que existía también para OO. […]

  20. @Simon Phipps
    As an intellectual property attorney in private practice, I think I fully understand the establishment of client relationships ;-) I have never asked advice directly of Sun Legal since I know of no-one within that group, my previous questions have mostly been aimed at them via the Sun Development team, since there seems to be no other way of doing that within the project. Indeed, my questions/comments would have been mostly in a professional capacity from one lawyer to another, the answers or replies to which could easily have been made under the cover of professional privilege. Sun Legal has never contacted me on any of these issues, possibly because they were never even relayed back to them via the project. That basically shows that Sun, as an entity, prefers to keep these things to itself, rather than discuss them with like-minded professionals, even those sworn to professional secrecy. I make no claim to anything other than that, I represent none of the companies involved in the project, nor any of its opponents, and still less any other volunteer organisation. I am “my own man”, as one might say. Perhaps therein lies the stumbling block ;-) In the end, it doesn’t matter to me one hoot, I have decided to withdraw from the project, at least from much of what I was doing until now, like many others, in an entirely voluntary capacity. Seven years on and we still have a monolith deciding what does or does not “belong” – the other corporations involved aren’t saints either, far from it, I’m not that naïve to believe in that, there’s always some other “interest” for a corporation to participate in a project like this than just sheer altruism. I can live with that, but I have decided to live without it, at least until such time as the “house” can be brought into order.


  21. Closed Source on Linux…

    One of the developers behind the Linux port of the new Flex Builder for Linux has a blog post about how building closed source software for linux is hard
    Mostly, all the problems boil down to the fact that Linux distributors keep patching the upstream…

  22. Is quite interesting that the first part involved in this fork battle for GPL was Novell,
    the same Novell that is still not GPL-3 compliant, and still searching alternative ways
    to licence open source that only Novell can distribute (Moonlight? )….

  23. […] Una sexta novedad, viene del modulo “Calc” (Planilla de Calculos) que, a partir de ahora, acepta las hojas de 1024 columnas (contra las 256 que ofrecía antes); y, permite un trabajo colaborativo en las hojas de calculo. Hay un solver que permite resolver los problemas de optimizacion y que pasa a integrar el modulo mismo (un código que se hizo esperar mucho, pues debió estar antes, ver articulo titulado :”History of Calc solver“). […]

  24. […] Una sexta novedad, viene del modulo "Calc" (Planilla de Calculos) que, a partir de ahora, acepta las hojas de 1024 columnas (contra las 256 que ofrecía antes); y, permite un trabajo colaborativo en las hojas de calculo. Hay un solver que permite resolver los problemas de optimizacion y que pasa a integrar el modulo mismo (un código que se hizo esperar mucho, pues debió estar antes, ver articulo titulado :"History of Calc solver"). […]

Comments are closed.