i should probably learn how makefiles work some day

[clarfonthey@toot.cat]

@eniko cmake ostensibly was a system to make makefiles but I don't think it does that any more and just has its own way of building stuff

[mkj@social.mkj.earth]

@dotstdy Well, make and cmake do solve the same problem, don't they?

@eniko

[runner@mastodon.art]

@eniko cmake makes make for c but you can make not make for not c

[zinnschlag@mastodon.gamedev.place]

@eniko Different things. CMake can create makefiles. Or project files for IDEs. Kinda like an additional abstraction layer.

CMake is slightly less gnarly than make, but still not fun.

[dotstdy@mastodon.social]

@mkj @eniko not really, cmake is a generator for 'make-like' things. Make is a thing which you use to actually execute a build.

[voidstarkat@unstable.systems]

@eniko cmake is it's own thing, it can do a lot more things, but a lot more complicated

[makiki@bark.lgbt]

@eniko different, IIRC cmake generates a makefile for make (please don't quote me on that, it was a while since manually I built something using make from source)

[cliftonr@wandering.shop]

@mkj @dotstdy @eniko

They create the same problem, if that's what you meant to say?

[clarfonthey@toot.cat]

@eniko make is kind of a mess, but very simple to learn, honestly

GNU make has a full manual online I've referenced frequently

the important bit to understand is that it is very based in traditional C building where each .c file is compiled into a .o file and then linked

so, it effectively does a topological/tree sort of dependencies where when you ask "make binary" it goes:

1. is binary newer than its dependencies? (by file modification time?)
2. are those dependencies newer than their dependencies?
3. etc.

and then builds the stuff as necessary. it also lets you parallelise which is cool

the most complicated bit is "phony" targets where instead of an actual file, you say something like "make build" which always runs commands and/or builds dependencies

also, load-bearing tabs; space-indenting doesn't work

[shanecelis@mastodon.gamedev.place]

@eniko Different and bleh but better than automake.

Build tools are a mess each generation must create their own flavor of dissatisfaction that they get used to—you know, like fashion.

[srazkvt@tech.lgbt]

@eniko cmake is really a bad name, it is very different from make. yea, as other comments said, it generates makefiles from a cmake definition, and does extra things like managing subprojects and stuff iirc

what really doesn't help is there is bmake, which is a make implementation from the BSD operating systems, and gnu make is often referred to as gmake, so it is a reasonable assumptions that cmake would also be a make implementation, but, yea, no

[duke_of_germany@mastodon.gamedev.place]

I looked into cmake a couple of times, but it seemed to bring so much complexity of its own.

I think it can make things easier (or at least quicker) when you want to pull in a ton of dependencies, which it can download & build for you.

My projects only have very few dependencies, so I just put in the time to write a versatile Makefile that works with all my projects.

How are you building your projects at the moment?

@eniko

[clarfonthey@toot.cat]

@eniko also like, the reason why external systems like cmake exist is because, specifically for the purpose of making C code, plain make is a pain in the absolute ass

while header files make dependency lookup relatively easy, make does not do that, and so you either have to just force-rebuild parts if you modify a header file or manually list all dependencies and update them when they change

so, cmake will figure that out for you, and so will ninja, etc.

but makefiles are still really good in any build system, because if you have a way of outputting the dependency tree into a file and the right commands you can just have make figure out how to run and parallelise it for you

[eniko@mastodon.gamedev.place]

@duke_of_germany I use visual studio. Or a batch file. Or a shell script

[yosh@toot.yosh.is]

@eniko

- make is a build system: it builds your code
- cmake is a meta-build system: it builds your build system

Which might seem confusing until you realize that build systems and compiler toolchains are often tied to specific operating systems. If you want to build portable code it helps to have something to abstract over them.

[xgranade@wandering.shop]

@yosh @eniko That's a helpful taxonomy, yeah. I'm guessing that by thr same logic, autoconf and friends are meta–build systems? I'm also curious where task runners like just or do-runner (my own attempt) fit into the picture — basically tools for keeping collections of tiny shell scripts.

I ask because make is a weird one to me in that it's both a build system and a task runner (thanks to .PHONY).

[oblomov@sociale.network]

@holsta @eniko I love make too! Especially how GNU make is different from BSD make is different from NMAKE!

Jokes aside, I really like make and try to make my Makefiles as cross-compatible as possible, although with nmake it's absolutely impossible beyond the basics.