Each project using SCons seems to be reinventing the wheel.
I would be glad to take someones directory layout, and/or solution for variant builds(debug/release), and/or testing framework, and/or best practices.
Even several not-too-simple examples would help.
You may be interested in Google's Software Construction Toolkit that was made open source in February 2009. It adds new features on top of SCons, such as improved Visual Studio project file generation, unit test functions, and distributed builds with distcc or incredibuild.
The SCons Recipes in the wiki is a good place to start. In addition take a look at other projects which use SCons, e.g. the Ardour build system. If that doesn't cut it, there are a few third party SCons extensions you may want to take a look at:
Parts
Aqualid
To the best of my knowledge, there are no SCons best practices which were agreed upon. The SCons community seems to favor adaptability over "canonicalization". It is not hard to design a decent SCons-based build system from scratch, though. (Once you have understood how VariantDir works, at least.)
If you are using Eclipse for C++ development you may want to check out this SCons builder plugin (http://nic-nac-project.org/~lothar/eclipse/update/SConsBuilderPlugin.html)
Another good example of SCons use is build system for MIT-licensed Godot game engine:
https://github.com/okamstudio/godot/wiki/compiling_intro
Related
I have recently approached by my co-worker about creating our own SCORM Packager. Honestly I have little clue about SCORM. I have look into Adobe Captivate and also Articulate Presenter. But unfortunately things that we worked here are highly customized. Our shop are half HTML and the other half is Flash.
Here are my questions:
Any suggestions to where I can get better understanding about SCORM (beside http://scorm.com)? I am looking something more hands-on approach.
is there a tool out there that can take our products (either HTML or
Flash) and wrap them into SCORM 1.2 zip compliant file?
Thanks in advance
For your course to be truly integrated with SCORM, you need to modify your ActionScript to report activities/status throughout the life of the course. This can't be achieved with a packaging tool, because it would have no way of knowing how your custom ActionScript is built and where to hook into it.
Adobe Captivate and Articulate Presenter have SCORM integration built in to their ActionScript, but it's under the hood where you can't see it unless you decompile their SWFs. The bits that are public -- the SCORM JavaScript, the manifest, etc. -- are only part of the story.
If you'd like to see a simple example of how to add SCORM code to a Flash file, see http://pipwerks.com/2008/04/27/how-to-add-basic-scorm-code-to-a-flash-movie/
It doesn't cover packaging, though.
To better understanding SCORM, I think you shoud go to the place where it born: http://legacy.adlnet.gov/Technologies/scorm/SCORMSDocuments/Forms/All%20Documents.aspx
ActivePresenter may be a good option.
I actually made a SCORM packager for my work. It's a bit of a process, but I think the best place to start was to study some working examples. You say you're doing SCORM 1.2, here are the reference files that you'll need; it has the CAM manual which tells you how the manifest file should be built. It also includes the SCORM 1.2 test suite you'll need to use to make sure your package conforms to SCORM, and that the content launches and communicates with the API correctly. The Test Suite is a bitch to setup though, and I recommend setting up a windows XP virtual machine image to test with(I used Parallels).
About your second question, I'm sure there is some public Scorm packaging applications out there, but we didn't find any that fit our needs (hence the need to build our own). You may want to look some more before creating your own from scratch; it will be a lengthy process.
95% of my time I program ASP.NET (MVC) web sites.
Should I care about MSBuild?
We use MSBuild with CruiseControl.Net to manage the builds of most of our big ASP.NET projects. For every commit of one member of the team, a build is launched. It helps us detect
quickely incompatibilities before moving a feature to "staging" or "production".
I think it is really usefull when working with a team on the same ASP.NET project or if you are working alone on a big project.
That depends on your development environment.
If you have other folks that do deployment of your systems, and they take care of the build and deployment environment, then MSBuild probably won't be necessary for your work.
On the other hand, if you need to configure the build script to understand special situations that your code comes up with, then you will definitely need to understand MSBuild scripts.
Even for a one-man shop, it's a useful tool to know, especially if you are configuring a continuous integration server like Hudson.
No. Until you have to.
Its not absolutely necessary to know MS Build, but it is useful to know.
It might not be needed for all kind of projects, but it is extremely useful when you are working on a huge code base with automated custom build solution/ nightly build/developer builds so on and so forth.
It's unlikely, unless you choose to use it, or you start to make use of Team Foundation Server's Team Build.
Your development processes need to get to a certain complexity before automated builds really deliver their true value and/or if you find need for automatic deployment (including database changes if applicable).
The coming Visual Studio 2010 is going to make it far easier to use, but for now it retains a fairly steep learning curve which you can avoid by using alternatives, or commercial products (e.g. Visual Build Pro, Final Builder etc).
The nice thing is that it is part of the .Net framework, so it's already available as long as you have the framework installed (which it probably is).
So, in short, not really. It's something very useful and powerful though, setting up deployments using MSBuild can be very, very useful.
What should a developer know about MsBuild?
Every developer should know it exists and it's basic capabilities. If know it exists you won't duplicate its features and will know what it can do for you, when you need it.
Minimum:
As an exercise, build your project through the command line: msbuild myproj.sln
Know the role of continuous integration
A little more than minimum:
Hack your csproj (or vbproj) with a message task, so it outputs something during clean.
All done. When you need to know more, you'll figure it out.
Closed. This question does not meet Stack Overflow guidelines. It is not currently accepting answers.
Questions asking us to recommend or find a tool, library or favorite off-site resource are off-topic for Stack Overflow as they tend to attract opinionated answers and spam. Instead, describe the problem and what has been done so far to solve it.
Closed 9 years ago.
Improve this question
A few years ago I looked into using some build system that isnt Make, and tools like CMake and SCons seemed pretty primitive. I'd like to find out if the situation has improved. So, under the following criteria, what is currently the best build tool:
platform agnostic: should work on windows, linux, mac
language agnostic: should have built-in support for common things like building C/C++ and other static langs. I guess it doesn't need to support the full autotools suite.
extensible: I need to be able to write rules to generate files, like from restructuredText, latex, custom formats, etc. I dont really care what language I have to write the rules in, but I would prefer a real language rather than a DSL.
I would prefer to avoid writing any XML by hand, which I think for example ant requires.
Freely available (preferably open source)
The term "best" is slightly subjective, but I think answers can be rated objectively by the criteria above.
I'd definitively put my vote up for premake. Although it is not as powerful as it's older brothers, it's main advantage is absurd simplicity and ease of use. Makes writing multi-compiler, multi-platform code a breeze, and natively generates Visual Studio solutions, XCode projects, Makefiles, and others, without any additional work needed.
So, judging purely by the criteria set forth in the question, the build system that seems like the best fit is probably waf - pure Python, provides support for C++ and other languages, general, powerful, not a DSL.
However, from my personal experience, I prefer CMake for C++ projects. (I tried CMake, SCons, and waf, and liked them in roughly that order). CMake is a general solution, but it has built-in support for C++ that makes it nicer than a more generic solution when you're actually doing C++.
CMake's build model for C++ is more declarative and less imperative, and thus, to me, easier to use. The CMake language syntax isn't great, but a declarative build with odd syntax beats an imperative build in Python. Of the three, CMake also seems to have the best support for "advanced" things like precompiled headers. Setting up precompiled headers reduced my rebuild time by about 70%.
Other pluses for CMake include decent documentation and a sizable community. Many open source libraries have CMake build files either in-tree or provided by the CMake community. There are major projects that already use CMake (OGRE comes to mind), and other major projects, like Boost and LLVM, are in the process of moving to CMake.
Part of the issue I found when experimenting with build systems is that I was trying to build a NPAPI plugin on OS X, and it turns out that very few build systems are set up to give XCode the exact combination of flags required to do so. CMake, recognizing that XCode is a complex and moving target, provides a hook for manually setting commands in generated XCode projects (and Visual Studio, I think). This is Very Smart as far as I'm concerned.
Whether you're building a library or an application may also determine which build system is best. Boost still uses a jam-based system, in part because it provides the most comprehensive support for managing build types that are more complex than "Debug" and "Release." Most boost libraries have five or six different versions, especially on Windows, anticipating people needing compatible libraries that link against different versions of the CRT.
I didn't have any problems with CMake on Windows, but of course your mileage may vary. There's a decent GUI for setting up build dependencies, though it's clunky to use for rebuilds. Luckily there's also a command-line client. What I've settled on so far is to have a thin wrapper Makefile that invokes CMake from an objdir; CMake then generates Makefiles in the objdir, and the original Makefile uses them to do the build. This ensures that people don't accidentally invoke CMake from the source directory and clutter up their repository. Combined with MinGW, this "CMake sandwich" provides a remarkably consistent cross-platform build experience!
Of course that depends on what your priorities are. If you are looking primarily for ease of use, there are at least two new build systems that hook into the filesystem to automatically track dependencies in a language agnostic fashion.
One is tup:
http://gittup.org/tup/
and the other is fabricate:
http://code.google.com/p/fabricate/
The one that seems to be the best performing, portable, and mature (and the one I have actually used) is tup. The guy who wrote it even maintains a toy linux distro where everything is a git submodule, and everything (including the kernel) is build with tup. From what I've read about the kernel's build system, this is quite an accomplishment.
Also, Tup cleans up old targets and other cruft, and can automatically maintain your .gitignore files. The result is that it becomes trivial to experiment with the layout and names of your targets, and you can confidently jump between git revisions without rebuilding everything. It's written in C.
If you know haskell and are looking for something for very advanced use cases, check out shake:
http://community.haskell.org/~ndm/shake/
Update: I haven't tried it, but this new "buildsome" tool also hooks into the filesystem, and was inspired by tup, so is relevant:
https://github.com/ElastiLotem/buildsome
CMake
CMake is an extensible, open-source
system that manages the build process
in an operating system and in a
compiler-independent manner.
Gradle seems to match all the criteria mentioned above.
It's a build system which took the best of Maven and Ant combined. To me, that's the best.
The Selenium project is moving over to Rake, not because its the best but because it handles multiple languages slightly better than all the other build tools and is cross platform (developed in Ruby).
All build tools have their issues and people learn to live with them. Something that runs on the JVM tends to be really good for building apps so Ant, Maven (i know its hideous), Ivy, Rake
Final Builder is well known in Windows world
smooth build matches most of your requirements.
platform agnostic: yes, it's written in java
language agnostic: it doesn't support c/c++t yet, only java but it is extensible via plugins written in java so adding more compilers support is not a problem
extensible: yes, you can implement smooth function via java plugin, you can also create smooth function via defining it as expression built of other smooth functions.
I would prefer to avoid writing any XML: you won't see a single line of it in smooth build
Freely available: yes, Apache 2 license
disclosure: I'm the author of smooth build.
I'm looking to use SCons as my prefered method of building my mainly Qt based applications. I'm just learning SCons and I'm struggling to find documentation or tutorials on the topic. Can anyone point me in the right direction please?
This is a start but is there anything better out there?
(I work mainly on Windows)
Kind Regards,
We are using Qt4 and SCons together on Windows simply because we need SCons excellent customization possibilities. The Qt4 tools have proved themselves to be complete enough for our needs, although we do not use all facets of the Qt4 toolkit. The manual is on the Qt4 tools web page
Try here and here.
I would suggest you though to try cmake instead. It has much better documentation and is being used by KDE.
I have created a desktop app and now I need to install in on a client's computer.
However, the client would like to have a wizard to install. Like Visual Studio setup project allows you to add an installer.
Does Qt allow you to create an installer or do I need to use a 3rd party installer like InstallShield or Wise?
You should use the Qt Installer Framework :
http://doc.qt.io/qtinstallerframework/ifw-overview.html
I use Inno and like it a lot. I've tried a few others and this one worked well for me. (and free)
You definitely need a third party installer. A few good ones have already been mentioned. If you decide to go with a paid solution bitrock's installer is a perfect choice and they are also Qt centric and their main business is around Qt.
As an open source alternative I would suggest NSIS
If you only target Windows, you can use WiX (Windows Installer XML), which can be integrated into Visual Studio and MSBuild, so relatively easy to use. It's free and produces valid MSI files, which may be a requirement anyway.
If you rather need a simple wizard setup, give InnoSetup a try.
I think better to use a third party software like installshield. They are optimized for the packaging purpose and provide much customizable options.
If you have Visual Studio already, you can continue to use a setup project to distribute your application. The tools are built in. This is the technology that WiX "replaced" (more on that later), and it's what I do. It's not an ideal solution, but it gets me an MSI, which is how Windows software should be installed these days. Using InstallShield or something might be better, but to be honest I've never had a good experience with any third party installers. This is why I just stuck with the less-than-ideal setup project; it beats spending a lot on expensive, ugly and often frustrating third party installer creation tools. In short, it's a very pragmatic solution, and pragmatic solutions make sense.
As for WiX: I really don't recommend it at all. It seems like a great idea, but after a few months I found myself switching back to the setup projects. Even though he's been using WiX for a year more than I have been using setup projects, our WiX expert takes twice as long to get anything done. (He's a terrific programmer, too, just a bit blinded by open source.) You end up with thousands of copied text lines that you need to maintain. With a couple different projects, it becomes an unmaintainable mess.
I would not suggest attempting to build an installer in Qt yourself. In addition to having to get a lot of behavior just right, as a Qt application it will require the Qt libraries. Unless you statically link them, which is possible with the commercial edition (not LGPL) but difficult and not recommended. Plus then you'd be including two copies of the Qt libraries in your download.
Qt itself seems to use the nullsoft installer. That alone should tell you building your own is not a good idea. :)