Installation of Julia on SCO OpenServer

The version of FreeBSD on which recent SCO OpenServer is based is FreeBSD 10, which has been EOL for a long time. Julia has only ever worked on FreeBSD 11+, and notably there were a lot of changes between 10 and 11 such that supporting 10 would have been exceedingly difficult. Currently Julia only supports FreeBSD 12+ and the official binaries do not work on 11, so I wouldn’t expect them to work on 10, much less a separate system based on 10.

If you want to try building Julia on OpenServer, start here: https://github.com/JuliaLang/julia/blob/master/doc/src/devdocs/build/build.md. You’ll need to set USE_BINARYBUILDER=0 as the BinaryBuilder-built dependencies do not support OpenServer (nor FreeBSD < 12). The various compilers and software you need are listed on the page I linked. Each dependency will need to support OpenServer before Julia could.

5 Likes

I’m finally getting back to this… I went to the link you provided but I’m not advanced enough to figure out what to do. The first line of scrip i ran

git config --global url."https://".insteadOf git://

gave me   

git not found

I assume I'm supposed to get a program called git

I think I need more specific information

Maybe I should contact [PallHaraldsson](https://github.com/PallHaraldsson)?

Download git from here:
https://git-scm.com/downloads

Then do

git clone https://github.com/JuliaLang/julia.git
cd julia
make
make install

I grabbed one of the files from Git - Downloads
I chose an older one (but not the oldest) in anticipation of having less
problems. I un-zipped it and extracted the tar file. Here’s the listing
of the directory:

.git git-pull-script
COPYING init-db.c
Makefile ls-tree.c
README merge-base.c
blob.c merge-cache.c
blob.h object.c
cache.h object.h
cat-file.c read-cache.c
check-files.c read-tree.c
checkout-cache.c rev-tree.c
commit-tree.c revision.h
commit.c sha1_file.c
commit.h show-diff.c
convert-cache.c show-files.c
diff-cache.c tree.c
diff-tree.c tree.h
fsck-cache.c unpack-file.c
git-export.c update-cache.c
git-merge-one-file-script usage.c
git-prune-script write-tree.c

What’s my next step?

make
make install

make gives me:

gcc -g -O2 -Wall -o update-cache update-cache.c
UX:make: ERROR: cannot load gcc (bu24).
*** Error code 1 (bu21)
UX:make: ERROR: fatal error.

I’m on git-0.5

now I assume I need to find gcc and load it?

You went back too far. The most recent version of git is 2.37.3.

git-2.37.3

make gives me:

UX:make: ERROR: line 31: Syntax error

shall I go back to half way between .5 and 2,37?

Yeah, I’m sorry, but this is not gonna work. Porting to a new operating system is a multi-month effort by someone experienced with this kind of work. Your best bet is to upgrade to the FreeBSD based versions and use the FreeBSD binaries.

4 Likes

Could you be a little more specific please, FreeBSD based version of git or julia?

FreeBSD version of SCO OpenServer.

2 Likes

Does that exist? I guess I could ask Xinuos…

1 Like

Yes, though as @ararslan mentioned above it looks like you’ll only be able to get something based on FreeBSD 10, so that probably won’t work out of the box, though it’ll probably be easier than trying to compile for a wholly unsupported OS.

1 Like

As near as I can figure out is that “make” is a c compiler. So, what does “make” look for that it’s trying to compile? the pseudo compiler i work with has to have a source code file to compile. Apparently, there is some kind of source file that “make” is looking at that has something it doesn’t like on line 31. So, fix it, and try again. That’s what I have been doing for thirty years, I’ve just never had to deal with c compilers. If julia is open source I should be able to get the source code, provided it’s written in c , and compile it in c . Granted there may be things a later version of c can handle that the older versions cannot, in that case we change the source code. What I can’t figure out is what I need git for, does it compile julia?

I really need to get julia running on SCO so I can begin converting my 1.5 million lines of code a little at a time. I emailed the julia (whatever the link I got for paid for support is, I’ll have to look that up) and never got an answer. You are the only guys that have responded and tried to help.

1 Like

As @Keno said, porting Julia to a new operating system is a multimonth process for the Julia core team. You give the impression of having a level of skill that would suggest if you start learning about the process now you will be able to start that multi month process in a year or two. That’s not meant to be an insult or anything, it just sounds like you need to come up to speed on many things you don’t have experience with.

My suggestion is to either pay someone to do this port, so you can focus on rewriting your own code, or perhaps consider moving away from SCO? What is keeping you on old SCO versions?

2 Likes

The plan is for future development to exist with the current application, developing new functions using julia and rewriting older routines in julia as we go along. We can make the two exist like we’re already existing with perl routines. Eventually the whole package is in julia and then other operating systems become available. This requires julia to work on SCO. We do not want to wait until the whole package is converted before adding features. I’ll bet I can make it work if I have someone to answer questions, I did spend my first 6 years programming in octal code, got pretty fast with a ten key, if there are no 8’s or 9’s

So, you have a big software project written in something other than C and it runs on an old SCO operating system, and you want to slowly convert it to Julia. Fine. Here’s the question. Which is easier, converting the existing code you understand to run on a different OS that Julia already runs on, and then slowly converting your code to Julia, or porting Julia to run on the old SCO OS and then slowly porting to Julia and then once you’ve gotten far enough along, porting the whole thing to a different OS?

Real honest question. Unless you have a lot of OS specific code in your existing codebase it might make more sense to convert away from SCO first? Porting Julia to old SCO is likely to just raise a LOT of OS specific questions that noone will be able to provide the answers to.

1 Like

Also, do you really a have compelling reason for using Julia on SCO OpenServer instead of any of the other already supported operating systems, besides curiosity of trying it out?

To make it absolutely clear: the Julia ecosystem at large relies a lot on open source infrastructure for dealing with binary libraries. Infrastructure which, to put it bluntly, no one is going to help you with for a niche proprietary operating system. Even if you’re going to manage to build Julia itself for SCO OpenServer (which at the moment looks far away) keep in mind that it’s nearly certain anything related to binary libraries won’t work at all (which I believe I said already a couple of months ago).

2 Likes

Let me expand on that a bit. I’m no expert, but my understanding is Julia uses the LLVM compiler suite under the hood. That’s written in C++. It also relies on some form of the BLAS libraries, possibly written in Fortran. The package manager requires git for some functions, git is an SCM/version control system. Julia uses ssh to enable its distributed functions. It uses the PCRE regular expressions library, it uses who knows what else… Your personal project is 1.5M lines of code. The LLVM compiler which Julia relies on is about 7M and that’s before you even get to Julia itself. You are at the stage where you’re learning what make is… You need to be at the stage where you know not just what make is but details about which version of the c,c++,and Fortran compilers are required to build LLVM, OpenBLAS, and PCRE… put together those code bases are 10-20x larger than your own code base… And that’s before we even get to the question of whether you need to figure out how to build the gcc,g++,Fortran on SCO. Your project could easily involve porting 100M lines of code ultimately.

Just don’t do it.

1 Like

There is another option that I am reluctant to pursue and that requires 2 conversions and the first one is dealing with non open source software that I have to buy. That one runs on Linux and I expect it not to be real smooth using the same data bases, I already know most of the changes I have to make. Then there is the transition the users will have to go through to change their servers which I want to put off for awhile yet. Finally the conversion to julia and sql data bases. which could be gradual at that point.

If I put julia on SCO I have sql data bases on all the additions I add and when everything else is on julia and sql then the transition to Linux should be smoother and simpler for the users. I’m leaning toward funding installation of julia on SCO rather than the non open source software.