Coders Edge
  
Modern Application 
Development
questions and answers on compiling
Open Source Code
in a Linux environment, but it will work for any Open Source

How does one get a source rpm

go to an rpm repository and get it there. It gets burried farther and farther into the Fedora webpage as the page is modded. There will be alist of repositories. Pick one. Find the rpm that you want.

How do I get the code that is in the source rpm?

The code is put into rpmbuild in your home directory as a tar archieve. There will typically also be patches there.

How do I unzip the file?

move it somewhere else and unzip it there. For example you might create a project bin in your home area. Create a directory, move the files you find in rpmbuild over there. use tar to extract the code. apply patches.

How do I apply patches?

Once I have the code what do I do with it?

You need to find out what kind of package it is. There are various tool-chains to correctly configure the software. The code could be of many types. I am primarily interested in C/C++ so that is usually what I find when I get source code. But the code could really be for any programming language.

When you have the code it will not be configured for your system. If you are scratching your head you might not think to look for a README file. If there is one there, then read it! For some code you use the autoconf/make-configure/ configure/ make all

For other code (Qt) you use gmake -cproject and gmake /make

There are a very many different versions of this same basic process. For example some times things are needing to use cmake.

In any case if you were an expert such as myself you could go very old school and hand-roll your make files. This is what we used to do 15 years ago. Now adays it is better to use an automated process. That way dependancies will be easily met and you will not waste your time learning arcane makefile rules. Time wasted on these now-easy things is time wasted!

If you do a build and you do not have all of the dependancies you need to go and get them (as explained below). When ever you update dependancies you neet to recreate your make files by going through the whole configureation process again (whatever it is for the code). These are the kinds of skills that need to become second nature. And when you are working on a project you do it so little that you tend to forget what it is (because you get hypnotized by the problem and need to dive into it. That is why an engineer has notes! Be yee the holder of the keys. Knowledge of the toolchain and the build system is one of the keys. You don't really need to memorize this but it is better if it becomes second nature. For myself, if I down load source code, it usually doesn't take me long at all to have the stuff built and running on a valid system.

One of the problems that is always faced by software engineers is that old-time folks are often fearfull for their jobs. Or, people want to desparately be seen as 'the expert'. They don't really believe n open software even though they work in open source! Remember, Open Source hasn't been around forever. And so you get these people who think that they have the secret stuff and they aren't going to tell you what it is. They put traps in the code for novice engineers. They hold back on information. These pyschopathic people permiate the software industry, hiding out in their fear in the dark, fingers glued to their latest little input contraption. If you want to be one of these software trolls, hiding stuff, being secret with your code, you can do this with your own code at your house on your own projects. But you should never do this at work. And only if it were your company and you really do own the code would it be moral to do this (though not wise. you are not going to live forever. no one will accept a legacy of broken coding practices pretending to be obfuscation. They will redevelop your ideas with new idioms and have product htat is better than what you have made and throw away your old crap and obfuscated code and you will have no legacy at all. And you have to wonder if that is the legacy that you'd want to have for yourself anyway?

A code head is one who loves to get things done and learns code as a way to do it. You only become really good at this stuff when you do real things. One of the real things that you should do is down load source modules, apply the patches, and build them to get your own compile. Once you do this enough times for enough projects then you can start to come up with your own projects too.

Historical note: one of the perverse things about 'genius' people is that they want to be more clever than you. And they use this need for cleverness as an excuse for obfuscation. They act like pyscho-paths, putting bombs in the code. If they have some great algorithm, they don't present it in a way that is useful to you. They lock it up on some server farm, locked into a tool that you can't get the code to, and you are stuck having to learn a programming language that they wrote themselves. And they wrote the compiler for it too. Do you really want to go down into that code-mine and dig around there looking for gold of the algorithm that you covet? I say if these people have gone to that much trouble: best leave their code alone. Don't waste your time learning their broken idioms. But if the code is really that good then why not contact the genius guy and pay him for the real deal and have him help you? If you really needed the code in question you would do just that if you are a fair-minded person who believes that folks should be paid for what they do and that benefit should come for those who provide real-world solutions.

A Psycho-path can perhaps be un-hypnotized and become useful and part of the team. The Psychotic who hires him, however, will be under the influence of this evil genius who is probably a master of hypnosis himself and then . . .well, that was called the computer industry in the 1970's and 1980's. Everyone's been fooled into thinking that they will all be rich. And we have seen what the result has been. Now the only real products that anyone wants are those based on Open Source: Nokia, Android, IPhone. Hallaluia! Now if these companies just won't be evil . . . we'll all be doing good.

What if the code doesn't compile?

How do I figure out what packages I need to have in order to build the code.

you may need the devel packages for dependancies. These are typically with a -devel in the rpm.

There are typically three types of rpm for a specific spin and processor architecture. First tehre is the rpm that already has compiled objects in it. Next there is the source rpm (which isn't necessarily tied to an architecture). Next there is a devel package which has the headers needed to build against an already valid and build module of that package. For example if package A has dependancy of package B we don't need the package B source rpm. We need the package B devel rpm. Only if you are working on the code of the dependancy will you need it's source RPM. And why would you need this?

When you do the compile pay attention to the messages that you see as the package compiles. These will hint at what dependanciees are needed.

why can't I just use yum or APT to get the source code?

There is no reason why someone couldn't make an rpm that has the demos that puts the code in a resonable place for you to use. Typically this is going to be down in /usr/share or some such place. If you do a find command from the root looking for source code (using the various source code extensions) you will probably find code there already. For example gtk and Qt provide some excellent demo programs. And if you run Qtcreator and have installed all of the demo packages the Welcome menus on Qtcreator let you copy this demonstration code, which is in a read-only directory for a user, into a local user directory. This is a new thing. In the old days you would need to copy this code yourself. Or, if you were not savey as to Linux tradition, or just didn't care, you can su over to root and compile the code in the directories where they are (don't do this.). Now the code comes to you with user mockbuild as the owner. There is a whole set of reasons why people do this and you can set up a mockbuild account and compile the code as that user. This is supposed to provide an added level of security.

The problem with rpm packages that install code is that the rpm also allows the script to compile code. And so it is always better to get the code uncompiled and NOT compile it automagically with rpm (yum or apt are built on rpm). This is useful to prevent root-kit insertion, etc etc etc.

The real deal corporate code builders most likely always open up packages in a virtualized environment so that if there were a root-kit put into to the OS, it would be a virtual one and, well, it can be deleted. It's only a file. At that level of security what can you learn from some random blog like this one? If you are that paranoid then you must have a reason to be that paranoid and you aren't going to document here at urge-central's coder's edge about such deep-secret things (that effect international trade and the world-dominant banks and think-houses.

Do I need a mockbuild account?

You do not. YOu can still compile code with your own user account. Even though mockbuild is not required, you may want to do this anyway for various security reasons. For some packages you may, in fact, need a mockbuild account. for this there is an rpm to do it! the following will work on Fedora Core systems:

sudo yum install mock

Also you may need to create user mock. If you don't know how to do that then you need to figure it out. Websearch and you will find (I could write it up here but it would just be what eeryone else has already said. There are many ways to add a user. They all need system administrators privledges.

How to proceed with the code?

My recommendation is to never be user root when you compile. Always use either your own or mockbuild accounts. When you make install you will need to have root privledges. In this case you will need to have your sudo privledges avaiable. There is a file /etc/sudoers in which you must put your user name and list privledges for yourself (you have to be root to do this). After that you can have root privledges for yourself everytime you prepend sudo to your command-line request. That way you don't need to use the su command and you dont' need to keep typing in the root password. If you don

t understand what I am saying and you want to be a Linux developer it is important that you learn these simple idioms. sudo is a very important command line tool and you really should know what it is. But, as with most things Linux, there are usually many ways to do the same thing. The sudo idiom can be, instead, an su idiom. You will just then need to know the root password everytime you do this.

  A custom of 
   excellent
 software is your
  solution for
   Custom 
   Expert 
   Software



  WP April 4, 2011

My content presented for the mobile user:
Message Mobile
Right Column Mobile
Left Column Mobile
Poem Shards Mobile
Coder's Edge Mobile