61–70 of 110 posts
Earlier quoted context omitted.
What about kqueue or eventports?
Kqueue and OS X's file watcher thing are worse than inotify. They give inexact reports of changes, so you have to do a bunch of manual scanning afterwards. I really don't understand the grandparent's gripe. Inotify scales well, supports race free "watch a whole directory tree", and has a nice API.
Checkout ninja-build. Generate ninja build files automatically using CMake. Ninja is really fast.
The drawback comes from the simplicity: all dependencies have to be explicitly listed, which you probably don't want to do by hand, so you need some other tool to make the dependency list.
I haven't seen how CMake works for this purpose, and I'd like to know more. What in particular do you do with CMake to use it with Ninja?
I didn't see any examples of .phony type rules. Can tup do this? I've recently found myself returning to make for multi-build system orchestration, e.g. Rust and C and PHP libraries. Does anyone have examples of using tup for this type of thing? Also, I've found myself really enjoying declarative build systems more, e.g. Cargo or Maven. It seems like for C there could be a simple set of standard tup files that are ru…
IMO that's just a killer for me, which stinks because I don't really feel like such a feature should be that complicated, but the developers seem to take the stance that phony targets, and `clean` and `install` are unnecessary.
Broncos vs Buccaneers Live Stream Free http://animarathon.com/node/14821
Checkout ninja-build. Generate ninja build files automatically using CMake. Ninja is really fast.
Ninja is definitely the best and simplest build system I've used. A great example of the "do one thing and do it well" philosophy. The drawback comes from the simplicity: all dependencies have to be explicitly listed, which you probably don't want to do by hand, so you need some other tool to make the dependency list. I haven't seen how CMake works for this purpose, and I'd like to know more. What in particular do yo…
Cmake solves the problem of "locate the library FOO of version X.Y, add the compilation flags, link flags, include folder, link folder, static link options, dynamic link options" and all the other details needed to make use of another software component. Sometimes that component is found in my operating systems "default" spot and other times it's in an install directory that I explicitly input. How do I tell Tup to find these components/libraries and then have Tup also add in everything needed for all the commands related to building things that use that component.
Also, I often have very different components going into different build targets that my project makes. How do the rules chain and build. In other words, just because I link one of my libraries with libssl doesn't mean I want every single source file and library I create in my project to then be linked with ssl
I may have missed how but.. Cmake solves the problem of "locate the library FOO of version X.Y, add the compilation flags, link flags, include folder, link folder, static link options, dynamic link options" and all the other details needed to make use of another software component. Sometimes that component is found in my operating systems "default" spot and other times it's in an install directory that I explicitly i…
You don't do that, because it's not really the job of Tup to do that. It's better to think of it as an alternative to Make as opposed to CMake, really. Because CMake is more like a generic build system (which is 'compiled' to a variety of other systems), with a billion built in rules and utilities and libraries for making the common cases easy amongst all them.
Tup is really just not in the same design space, although it is still a build tool. It'd probably be more appropriate to think of Tup as a thing that CMake would target, like Makefiles, MSVC Projects, or Ninja build files.
I may have missed how but.. Cmake solves the problem of "locate the library FOO of version X.Y, add the compilation flags, link flags, include folder, link folder, static link options, dynamic link options" and all the other details needed to make use of another software component. Sometimes that component is found in my operating systems "default" spot and other times it's in an install directory that I explicitly i…
Is this because you want to guarantee that all libraries have the dependencies explicitly defined? If nothing in that library is used, I don't think it has an effect on the output.
Honestly just curious, bc it sounds like a pain to declare different sets of libraries inside the same project.
Tup's main problem is it's unusual, and it doesn't have a library of build rules. But it's fast! On a related note, I've always wondered if it was possible to have a build system based on dynamic library injection / strace. The idea would be that you just write your build rules in shell script. Then, you run it with a special shell that catches open(), etc. in child processes (via library injection, etc). These syste…
There is such a build system, but I can't remember the name right now. It tracks system calls to see every file opened by the compiler to produce exact dependency graphs (assuming compiler is deterministic). The downside is that it's Linux only. If anyone remembers the name, please do share.