GNU Make Reviews

GNU Make is used as a build system tool. Most people don't use GNU Make directly but utilize other systems like CMake to generate Make files, which are then run by GNU Make. This is common for tasks like compiling C++ code. In the industry, AI developers, for example, use GNU Make in their work.

GNU Make is an industry standard and is integral in compiling C++ code. It enhances productivity by providing a reliable and widely-used tool for build automation.

GNU Make is free and widely used. It is the standard on Linux systems and is typically installed by default. Its handling of dependencies, where it does not rebuild files that have not changed, is a valuable feature shared across many build automation tools.

I am not familiar enough with it to suggest any specific new features or areas for improvement. It occupies its niche well.

I have been using GNU products for a few years as they are widespread and free to use.

GNU Make is definitely stable and considered the standard on any Linux operating system.

GNU Make is scalable, and I have not encountered any issues in this regard.

GNU Make does not provide traditional customer support. However, the documentation is good, and there are community-based supports like Stack Overflow where users can ask questions.

Positive

The initial setup of GNU Make is straightforward. It is part of the standard Linux operating system installation, so it doesn't require much setup.

It's hard to compare productivity boosts since GNU Make is a standard tool that everyone uses. It plays a crucial role in compiling code for the industry.

GNU Make is a free solution that comes with Linux, which positively impacts operational costs by eliminating licensing fees.

I would recommend GNU Make because it's the industry standard. However, I am unsure of its cross-platform capabilities, so I would need to research that.

I'd rate the solution nine out of ten.

GNU Make is such an essential tool that it is almost impossible to imagine working without it. Not having it, developers would probably have to resort to doing everything manually or via shell scripts. Tools such as automake and various IDEs that depend on GNU Make would be rendered useless.

Lack of any GUI, full-featured declarative syntax, wide adoption. Makefiles are extremely easy to work with using any preferred editor. GNU Make can be run directly from the terminal, not requiring any time wasted on clicking. Full-featured syntax allows building strategies as simple or as complex as one wishes, and declarative approach fits the task really well. Wide adoption also means that everybody knows what GNU Make is and how to use it.

Vanilla GNU Make does not support any kind of colored output. A wrapper named colormake exists to work around this, but native (opt-in) support would be welcome.

No, I have not encountered any stability issues with GNU Make. It is one of the most stable tools I have ever used.

No, I have not encountered any scalability issues with GNU Make. It is as scalable as the project's structure is, and then some. And if yet not enough, there's Automake.

There is no technical support. As with all GNU software, GNU Make is distributed "as-is" with no warranty and no support package. Documentation for GNU Make and a plethora of advice and examples on the Web make support unneeded anyway.

I did not used anything different before. GNU Make was always there for me.

Very straightforward. Just learn basics of GNU Make language and you're ready to go. Then learn more to be more terse or efficient with it.

GNU Make is free and open source software. Free as in "freedom." Just download the last version from your repository if you don't have it yet.

No, I did not evaluate other options. GNU Make is the standard tool, and I wished to work with it, as such.

GNU Make is an extremely helpful and automatic building tool, useful in many diverse appliances. It is extremely hard to imagine contemporary C/C++ development without help of GNU Make.

Read the docs. You'll be surprised at how much GNU Make can actually do when used correctly. It is definitely worth the time to read through the documentation and try out different concepts.

Built projects.

Building projects.

Tabs. GNU Make requires using the Tab symbol as the first symbol of command line for execution. In some text editors this can be problematic, as they automatically insert spaces instead of tabs.

No stability issues.

No scalability issues.

There’s no support for this product, it’s open source.

No previous solution.

Extremely straightforward.

There is no price for this product. No licensing. It’s open-source.

Ant. But GNU Make is significantly better in my opinion.

I think this product has all you need.

GNU make is a build automation utility for running builds on various Linux flavored platforms. It can easily build targets and can be integrated with other build automation utilities for this platform. It avoids rebuilding unneeded targets and thus saves time and improves overall efficiency. GNU make build process supports nesting of make files. You can easily specify a particular static pattern rule for compilation of source packages. You can do multiple level of code optimization during compilation using the optimization flags. Also, It can support various types of make file names using the flag option available.

GNU make has just the basic build automation features and is not smart enough to handle complex build issues e.g. it cannot handle circular dependency in the makefiles and requires you to manually fix them. Also it cannot generate builds targeted for different platform and requires the end user to use some other third party tool for the same. GNU make is a bad candidate for builds that require incremental builds often, as it does not support this feature. Due to all these features it is recommended for small to medium projects only and is not suitable for very complex and heavy projects which requires various circular dependency etc.

Free and open source build automation tool suitable for small to medium projects. It is available on almost all platforms. You can easily nest make files for multiple levels and nonstandard make file names are also supported with the help of the flag option. Makefiles contains various rules to execute, various include and library directives which aids in the compilation process. It uses time stamping feature to determine which modules needs a rebuild and executes them. Suffers from circular dependency and is not capable of handling very complex projects.

- One of the most popular build automation tools that are specially used on various *nix platforms.
- Build process is divided into various "Rules" which makes it very user friendly. Rules essentially contain dependency lists, files, targets, etc.
- Avoids rebuilding targets
- Has support for integrating with third party dependency builder tools, like Automake, from the GNU Project.
- Apart from the default makefile names, it supports non-standard makefile names using the -f or - - file flag option.
- Supports use of nested makefile usage.
- Supports optimized code compilation through various -O flags passed to the compiler through makefile.

- Since builds targeted for a particular platform cannot be run on a different platform, "Make" doesn't have the inbuilt functionality of tailoring a build targeted to a platform. It relies on other tools like AutoConf for platform based build customizations.
- Recursive make might result in circular dependency.
- Make parsers don't follow the standard model, as parsing a makefile without reading it is not possible.
- Writing makefiles is not easy as it requires a basic knowledge of make syntax.
- One major weakness of the make is its limited support for “if” conditionals. Writing make commands involving AND, OR, etc. is very cumbersome.
- Make has no data types, other than strings. There is no Boolean type.
- Make’s reliability is very poor and is not suitable for larger or incremental builds.
- Not being able to list any dependency to make will lead to a compilation failure. Each and every dependency has to be declared explicitly.
- Editing target files during build has an unpredictable impact on the build.
- Due to buggy makefiles containing circular dependency, target files get rebuilt even though none of its targets have changed since the last build.

One of the best things about GNU Make is that, it is available on almost all Linux platforms. Once you know the basic syntax of the Make file, you can start writing your own makefiles. Because writing makefiles for bigger projects with circular dependency is a very complex task, it is recommended to use alternative build automation tools. It's highly popular for smaller projects of lesser complexity.

Pros of GNU make-
1) It can use, delete, and regenerate intermediate files which do not need to be saved with a package
2) The -o -v option used along with make
3) Specify extra makefiles to be read using an environment variable through GNU make
4) Specify static pattern rules for source package compilation
5) Static pattern and search rules with vpath searches

Few cons of GNU make
1) Problems in fulfilling dependency with different kernel versions
2) Poor reliability for larger or incremental builds
3) Differentiates between two files on basis of time stamps and not the contents of the files
4) Environment variable inheritance and dependencies

Make tool, originally made for the GNU operating system, helps in the generation of executable from the main program source files. Make enables the installation of a program on the nix (unix,linux) platform through a process of running the configure command followed by make and then make install command. It automatically determines which modules of a program to recompile and automatically compiles them. It works on makefile database and last modification time stamps to update particular modules. The GNU make reads the makefile in the current destination directory and begins processing rules. The make files from GNU make basically contain explicit rules, implicit rules, comments and directives.