{"id":468,"date":"2016-12-22T13:33:52","date_gmt":"2016-12-22T13:33:52","guid":{"rendered":"https:\/\/blogs.ncl.ac.uk\/andreymokhov\/?p=468"},"modified":"2017-11-16T10:59:23","modified_gmt":"2017-11-16T10:59:23","slug":"graphs-in-disguise","status":"publish","type":"post","link":"https:\/\/blogs.ncl.ac.uk\/andreymokhov\/graphs-in-disguise\/","title":{"rendered":"Graphs in disguise: from todo lists to build systems"},"content":{"rendered":"

In this blog post we will look at an example of\u00a0using the algebra of graphs<\/a> for manipulating sequences<\/em> of items, which at first sight might not look like graphs, but are actually dependency graphs<\/em> in disguise. We will develop a\u00a0tiny DSL\u00a0for composing\u00a0todo lists on top of the alga library<\/a> and will\u00a0show how it can be used for planning a holiday and, on a more serious note, for writing software build systems. This blog post will partially answer\u00a0the question about possible applications of the algebra of graphs that was asked in this reddit discussion<\/a>.<\/p>\n

Update:<\/strong>\u00a0This series of blog posts was published as a functional pearl<\/a> at the Haskell Symposium 2017.<\/p>\n

<\/p>\n

Todo lists and the algebra of graphs<\/h4>\n

Todo lists<\/em> are sequences of items<\/em> that, as one would expect, need to be done. The order of items in the sequence matters, because some items may depend on others. The simplest todo list is the empty<\/em> one. Then we have todo lists containing a single item, from which we can build up longer lists\u00a0using the same operators we introduced\u00a0to construct graphs.<\/p>\n

An item will correspond to a graph vertex. We’ll use the\u00a0OverloadedStrings<\/code><\/strong> GHC extension, so we can create\u00a0todo items without explicitly wrapping them into a\u00a0vertex<\/code><\/strong>.\u00a0This will also allow everyone to choose their favourite representation for strings; plain old String<\/code><\/strong>\u00a0is fine for our examples:<\/p>\n

{-# LANGUAGE<\/span> OverloadedStrings #-}\r\nimport<\/span> Data.String<\/span>\r\n\r\nimport<\/span> Algebra.Graph<\/span>\r\nimport<\/span> Algebra.Graph.Util<\/span>\r\n\r\ninstance<\/span> (IsString<\/span> a<\/span>, Ord<\/span> a<\/span>) =><\/span> IsString<\/span> (Todo<\/span> a<\/span>) where<\/span>\r\n    fromString =<\/span> vertex .<\/span> fromString\r\n\r\nshopping<\/span> ::<\/span> Todo<\/span> String<\/span>\r\nshopping =<\/span> \"presents\"<\/span>\r\n<\/pre>\n
Here Todo<\/code><\/strong> is a Graph<\/code><\/strong> instance whose implementation\u00a0will be revealed later. One can combine several items\u00a0into a single todo list using the overlay<\/em> operator + of the algebra:<\/p>\n
shopping<\/span> ::<\/span> Todo<\/span> String<\/span>\r\nshopping =<\/span> \"presents\"<\/span> +<\/span> \"coat\"<\/span> +<\/span> \"scarf\"<\/span>\r\n<\/pre>\n
The semantics<\/em>\u00a0of a todo list is just a list of items in the order they can be completed, or Nothing<\/code><\/strong> if the there is no possible completion order that satisfies all dependency constraints between different items. We can extract the semantics using\u00a0todo<\/code><\/strong> function with the following signature:<\/p>\n
todo<\/span> ::<\/span> Ord<\/span> a<\/span> =><\/span> Todo<\/span> a<\/span> -><\/span> Maybe<\/span> [a<\/span>]\r\n<\/pre>\n
The overlay operator is commutative, therefore reordering items in the shopping list does not change the semantics:<\/p>\n
\u03bb><\/span> todo shopping\r\nJust<\/span> [\"coat\"<\/span>,<\/span>\"presents\"<\/span>,<\/span>\"scarf\"<\/span>]\r\n\u03bb><\/span> todo $<\/span> \"coat\"<\/span> +<\/span> \"scarf\"<\/span> +<\/span> \"presents\"<\/span>\r\nJust<\/span> [\"coat\"<\/span>,<\/span>\"presents\"<\/span>,<\/span>\"scarf\"<\/span>]\r\n\u03bb><\/span> shopping ==<\/span> \"coat\"<\/span> +<\/span> \"scarf\"<\/span> +<\/span> \"presents\"<\/span>\r\nTrue<\/span>\r\n<\/pre>\n
As you can see, the items are simply ordered alphabetically as there are no dependencies between them. Let’s add some! To do that we’ll use the connect<\/em> operator \u2192\u00a0from the algebra. When two todo lists are combined with\u00a0\u2192, the meaning is that all items in the first list must be completed before we can start completing items from the second todo list. I’m currently planning a holiday trip to visit friends and therefore will need to pack all stuff that I buy before travelling:<\/p>\n
holiday<\/span> ::<\/span> Todo<\/span> String<\/span>\r\nholiday =<\/span> shopping * \"pack\"<\/span> * \"travel\"<\/span>\r\n\r\n\u03bb><\/span> todo holiday\r\nJust<\/span> [\"coat\"<\/span>,<\/span>\"presents\"<\/span>,<\/span>\"scarf\"<\/span>,<\/span>\"pack\"<\/span>,<\/span>\"travel\"<\/span>]\r\n\u03bb><\/span> shopping ==<\/span> holiday\r\nFalse<\/span>\r\n\u03bb><\/span> shopping `isSubgraphOf`<\/span> holiday\r\nTrue<\/span>\r\n<\/pre>\n
Items \"pack\"<\/code><\/strong> and \"travel\"<\/code><\/strong> have been appended\u00a0to the end of the list even though \"pack\"<\/code><\/strong> comes before \"presents\"<\/code><\/strong> alphabetically, and rightly so: we can’t pack presents before we buy them!<\/p>\n
Now let’s\u00a0add a new dependency constraint to an existing todo list. For example, I might\u00a0want to buy a new scarf before a coat, because I would like to make sure\u00a0the coat looks good\u00a0with the new scarf:<\/p>\n
\u03bb><\/span> todo $<\/span> holiday +<\/span> \"scarf\"<\/span> * \"coat\"<\/span>\r\nJust<\/span> [\"presents\"<\/span>,<\/span>\"scarf\"<\/span>,<\/span>\"coat\"<\/span>,<\/span>\"pack\"<\/span>,<\/span>\"travel\"<\/span>]\r\n<\/pre>\n
Look how the resulting list\u00a0changed:\u00a0\"coat\"<\/code><\/strong> has been moved after\u00a0\"scarf\"<\/code><\/strong> to meet the new constraint! Of course, it’s not too difficult to add contradictory\u00a0constraints, making the todo list impossible to schedule:<\/p>\n
\u03bb><\/span> todo $<\/span> holiday +<\/span> \"travel\"<\/span> * \"presents\"<\/span>\r\nNothing<\/span>\r\n<\/pre>\n
There is nothing we can do to complete all items if there is\u00a0a circular dependency in our todo list: \"presents\"<\/code><\/strong>\u00a0\u2192 \"pack\"<\/code><\/strong> \u2192\u00a0\"travel\"<\/code><\/strong>\u00a0\u2192\u00a0\"presents\"<\/code><\/strong>.<\/p>\n
It may sometimes be useful to have some notion of item priorities<\/em>\u00a0to schedule some items\u00a0as soon or as late as possible.\u00a0Let me illustrate this with an example, by modifying our todo lists as follows:<\/p>\n
shopping<\/span> ::<\/span> Todo<\/span> String<\/span>\r\nshopping =<\/span> \"presents\"<\/span> +<\/span> \"coat\"<\/span> +<\/span> \"phone wife\"<\/span> * \"scarf\"<\/span>\r\n\r\nholiday<\/span> ::<\/span> Todo<\/span> String<\/span>\r\nholiday =<\/span> shopping * \"pack\"<\/span> * \"travel\"<\/span> +<\/span> \"scarf\"<\/span> * \"coat\"<\/span>\r\n<\/pre>\n
As you see, I now would like to phone my wife before buying the scarf to make sure it also matches the colour of one of her scarves (she has a dozen of them and I can’t possibly remember all the colours). Let’s see how this changes the resulting order:<\/p>\n
\u03bb><\/span> todo holiday\r\nJust<\/span> [\"phone wife\"<\/span>,<\/span>\"presents\"<\/span>,<\/span>\"scarf\"<\/span>,<\/span>\"coat\"<\/span>,<\/span>\"pack\"<\/span>,<\/span>\"travel\"<\/span>]\r\n<\/pre>\n
This works but is a little unsatisfactory:\u00a0ideally I’d like to phone my wife right before<\/em> buying the scarf. To achieve that I\u00a0can amend\u00a0the\u00a0shopping list by changing\u00a0the priority of the item \"phone wife\"<\/code><\/strong>:<\/p>\n
-- Lower the priority of items in a given todo list<\/span>\r\nlow<\/span> ::<\/span> Todo<\/span> a<\/span> -><\/span> Todo<\/span> a<\/span>\r\n\r\nshopping<\/span> ::<\/span> Todo<\/span> String<\/span>\r\nshopping =<\/span> \"presents\"<\/span> +<\/span> \"coat\"<\/span> +<\/span> low \"phone wife\"<\/span> * \"scarf\"<\/span>\r\n\r\n\u03bb><\/span> todo holiday\r\nJust<\/span> [\"presents\"<\/span>,<\/span>\"phone wife\"<\/span>,<\/span>\"scarf\"<\/span>,<\/span>\"coat\"<\/span>,<\/span>\"pack\"<\/span>,<\/span>\"travel\"<\/span>]\r\n<\/pre>\n
Aha, this is better: \"phone wife\"<\/code><\/strong>\u00a0got\u00a0scheduled as late as possible,\u00a0and is now right next to \"scarf\"<\/code><\/strong>, as desired. But wait — if my wife finds out that I gave a low priority to my phone calls to her, I’ll get into trouble! I need to find a better way to achieve the same effect. In essence, we would like to have a variant of the connect operator that pulls the arguments\u00a0together as close as possible during scheduling (and, alternatively, we may also want to repel arguments as far from each other as possible).<\/p>\n
-- Pull the arguments together as close as possible<\/span>\r\n(~<\/span>*~<\/span>) ::<\/span> Ord<\/span> a =><\/span> Todo<\/span> a -><\/span> Todo<\/span> a -><\/span> Todo<\/span> a\r\n\r\n-- Repel the arguments as far as possible<\/span>\r\n(><\/span>*<<\/span>) ::<\/span> Ord<\/span> a =><\/span> Todo<\/span> a -><\/span> Todo<\/span> a -><\/span> Todo<\/span> a\r\n\r\nshopping<\/span> ::<\/span> Todo<\/span> String<\/span>\r\nshopping =<\/span> \"presents\"<\/span> +<\/span> \"coat\"<\/span> +<\/span> \"phone wife\"<\/span> ~<\/span>*~<\/span> \"scarf\"<\/span>\r\n<\/pre>\n
This looks better and leads to the same result as the code above.<\/p>\n
The final\u00a0holiday<\/code><\/strong> expression can be visualised as follows:
\n\"Graph<\/a><\/p>\n
Here the overlay operator + is shown simply by placing its arguments next to each other, the connect operators are shown by arrows, and the arrow with a small triangle stands for the tightly connect<\/em> operator ~*~<\/code><\/strong>. By following the laws of the algebra, we can flatten the graph expression into a dependency graph shown below:
\n\"Dependency<\/a><\/p>\n
The graph is then linearised<\/em> into a list\u00a0of items by the\u00a0todo<\/code><\/strong> function.<\/p>\n
So, here you go: you can plan your holiday (or anything else) in Haskell using the alga library<\/a>!<\/p>\n
Constructing command lines in build systems<\/h4>\n
The above reminds me of build systems<\/a> that construct command lines for executing various external programs, such as compilers, linkers, etc. A command line is just a list\u00a0of strings, that typically include the path to the program that is being executed, paths to source files, and various configuration flags. Some of these strings may have order constraints between them, quite\u00a0similar to todo lists. Let’s see if we can\u00a0use\u00a0our tiny DSL for\u00a0todo lists<\/a> for describing command lines.<\/p>\n
Here is a simple command line to compile \"src.c\"<\/code><\/strong> with GCC compiler:<\/p>\n
cmdLine1<\/span> ::<\/span> Todo<\/span> String<\/span>\r\ncmdLine1 =<\/span> \"gcc\"<\/span> * (\"-c\"<\/span> ~<\/span>*~<\/span> \"src.c\"<\/span> +<\/span> \"-o\"<\/span> ~<\/span>*~<\/span> \"src.o\"<\/span>)\r\n\r\n\u03bb><\/span> todo cmdLine1\r\nJust<\/span> [\"gcc\"<\/span>,<\/span>\"-c\"<\/span>,<\/span>\"src.c\"<\/span>,<\/span>\"-o\"<\/span>,<\/span>\"src.o\"<\/span>]\r\n<\/pre>\n
cmdLine2<\/span> ::<\/span> Todo<\/span> String<\/span>\r\ncmdLine2 =<\/span> \"gcc\"<\/span> * (\"-o\"<\/span> ~<\/span>*~<\/span> \"src.o\"<\/span> +<\/span> \"-c\"<\/span> ~<\/span>*~<\/span> \"src.c\"<\/span>)\r\n\r\n\u03bb><\/span> cmdLine1 ==<\/span> cmdLine2\r\nTrue<\/span>\r\n\u03bb><\/span> todo cmdLine2\r\nJust<\/span> [\"gcc\"<\/span>,<\/span>\"-c\"<\/span>,<\/span>\"src.c\"<\/span>,<\/span>\"-o\"<\/span>,<\/span>\"src.o\"<\/span>]\r\n<\/pre>\n
As you can see, the above change has no effect, as we\u00a0would expect from the commutativity of +. Replacing\u00a0~*~<\/code><\/strong>\u00a0with the usual connect operator on the other hand sometimes leads to changes in the semantics:<\/p>\n
cmdLine3<\/span> ::<\/span> Todo<\/span> String<\/span>\r\ncmdLine3 =<\/span> \"gcc\"<\/span> * (\"-c\"<\/span> * \"src.c\"<\/span> +<\/span> \"-o\"<\/span> * \"src.o\"<\/span>)\r\n\r\n\u03bb><\/span> cmdLine1 ==<\/span> cmdLine3\r\nFalse<\/span>\r\n\u03bb><\/span> todo cmdLine3\r\nJust<\/span> [\"gcc\"<\/span>,<\/span>\"-o\"<\/span>,<\/span>\"-c\"<\/span>,<\/span>\"src.c\"<\/span>,<\/span>\"src.o\"<\/span>]\r\n<\/pre>\n
The resulting\u00a0sequence is correct from the point of view of a dependency graph, but is not a valid command line: the flag pairs got pushed apart. The change in semantics is recognised by the algebra and a rerun of the build system should reveal the error.<\/p>\n
As a final exercise, let’s write\u00a0a\u00a0function that transforms command lines:<\/p>\n
optimise<\/span> ::<\/span> Int<\/span> -><\/span> Todo<\/span> String<\/span> -><\/span> Todo<\/span> String<\/span>\r\noptimise level =<\/span> (* flag)\r\n  where<\/span>\r\n    flag =<\/span> vertex $<\/span> \"-O\"<\/span> ++<\/span> show<\/span> level\r\n\r\n\u03bb><\/span> todo $<\/span> optimise 2<\/span> cmdLine1\r\nJust<\/span> [\"gcc\"<\/span>,<\/span>\"-c\"<\/span>,<\/span>\"src.c\"<\/span>,<\/span>\"-o\"<\/span>,<\/span>\"src.o\"<\/span>,<\/span>\"-O2\"<\/span>]\r\n<\/pre>\n
As you can see, optimise 2<\/code><\/strong>\u00a0appends the optimisation flag \"-O2\"<\/code><\/strong> at the end of the command line, i.e. optimise 2 ==\u00a0(* \"-O2\")<\/code><\/strong>.<\/p>\n
Command lines in real build systems contain many\u00a0conditional<\/em> flags that are\u00a0included only when compiling certain files on certain platforms, etc. You can read about\u00a0how we deal with conditional flags in Hadrian here<\/a>.<\/p>\n
Under the hood<\/h4>\n
Scheduling a list of items subject to dependency constraints is a\u00a0well-known problem, which is solved by topological sort<\/em><\/a>\u00a0of the underlying dependency graph.\u00a0GHC’s containers<\/code><\/strong> library has an implementation of topological sort in\u00a0Data.Graph<\/code><\/strong> module. It operates on adjacency lists and to reuse it we can define the following Graph<\/code><\/strong> instance:<\/p>\n
newtype<\/span> AdjacencyMap<\/span> a =<\/span> AM<\/span> { adjacencyMap ::<\/span> Map<\/span> a (Set<\/span> a) }\r\n    deriving<\/span> (Eq<\/span>, Show<\/span>)\r\n\r\ninstance<\/span> Ord<\/span> a<\/span> =><\/span> Graph<\/span> (AdjacencyMap<\/span> a<\/span>) where<\/span>\r\n    type<\/span> Vertex<\/span> (AdjacencyMap<\/span> a) =<\/span> a\r\n    empty       =<\/span> AM<\/span> $<\/span> Map<\/span>.<\/span>empty\r\n    vertex  x   =<\/span> AM<\/span> $<\/span> Map<\/span>.<\/span>singleton x Set<\/span>.<\/span>empty\r\n    overlay x y =<\/span> AM<\/span> $<\/span> Map<\/span>.<\/span>unionWith Set<\/span>.<\/span>union\r\n        (adjacencyMap x) (adjacencyMap y)\r\n    connect x y =<\/span> AM<\/span> $<\/span> Map<\/span>.<\/span>unionsWith Set<\/span>.<\/span>union\r\n        [ adjacencyMap x,<\/span> adjacencyMap y\r\n        ,<\/span> fromSet (const<\/span> .<\/span> keysSet $<\/span> adjacencyMap y)\r\n                  (keysSet $<\/span> adjacencyMap x) ]\r\n\r\nadjacencyList<\/span> ::<\/span> AdjacencyMap<\/span> a<\/span> -><\/span> [(a<\/span>, [a<\/span>])]\r\nadjacencyList =<\/span> map<\/span> (fmap<\/span> Set<\/span>.<\/span>toAscList) .<\/span> Map<\/span>.<\/span>toAscList .<\/span> adjacencyMap\r\n\r\n\u03bb><\/span> adjacencyList $<\/span> clique [1<\/span>..<\/span>4<\/span>]\r\n[(1<\/span>,<\/span>[2<\/span>,<\/span>3<\/span>,<\/span>4<\/span>]),<\/span>(2<\/span>,<\/span>[3<\/span>,<\/span>4<\/span>]),<\/span>(3<\/span>,<\/span>[4<\/span>]),<\/span>(4<\/span>,<\/span>[]<\/span>)]\r\n<\/pre>\n
Todo<\/code><\/strong> is built on top of the TopSort<\/code><\/strong> graph instance, which is just a\u00a0newtype wrapper around AdjacencyMap<\/code><\/strong> based representation of graphs:<\/p>\n
newtype<\/span> TopSort<\/span> a =<\/span> TS<\/span> { fromTopSort ::<\/span> AdjacencyMap<\/span> a }\r\n    deriving<\/span> (Show<\/span>, Num<\/span>)\r\n\r\ninstance<\/span> Ord<\/span> a<\/span> =><\/span> Eq<\/span> (TopSort<\/span> a<\/span>) where<\/span>\r\n    x ==<\/span> y =<\/span> topSort x ==<\/span> topSort y\r\n<\/pre>\n
The custom Eq<\/code><\/strong> instance makes sure that graphs are considered equal if their topological sorts coincide. In particular all cyclic graphs fall into the same equivalence class corresponding to <\/code>topSort g == Nothing<\/code><\/strong>:<\/p>\n
\u03bb><\/span> path [1<\/span>..<\/span>4<\/span>] ==<\/span> (clique [1<\/span>..<\/span>4<\/span>] ::<\/span> TopSort<\/span> Int<\/span>)\r\nTrue<\/span>\r\n\u03bb><\/span> topSort $<\/span> clique [1<\/span>..<\/span>4<\/span>]\r\nJust<\/span> [1<\/span>,<\/span>2<\/span>,<\/span>3<\/span>,<\/span>4<\/span>]\r\n\u03bb><\/span> topSort $<\/span> path [1<\/span>..<\/span>4<\/span>]\r\nJust<\/span> [1<\/span>,<\/span>2<\/span>,<\/span>3<\/span>,<\/span>4<\/span>]\r\n\u03bb><\/span> topSort $<\/span> transpose $<\/span> clique [1<\/span>..<\/span>4<\/span>]\r\nJust<\/span> [4<\/span>,<\/span>3<\/span>,<\/span>2<\/span>,<\/span>1<\/span>]\r\n\u03bb><\/span> topSort $<\/span> circuit [1<\/span>..<\/span>4<\/span>]\r\nNothing<\/span>\r\n<\/pre>\n
Function topSort<\/code><\/strong>\u00a0simply calls Data.Graph.topSort<\/code><\/strong> performing\u00a0the necessary plumbing, which is not particularly interesting.<\/p>\n
Have a great holiday everyone!<\/p>\n","protected":false},"excerpt":{"rendered":"
In this blog post we will look at an example of\u00a0using the algebra of graphs for manipulating sequences of items, which at first sight might not look like graphs, but are actually dependency graphs in disguise. We will develop a\u00a0tiny DSL\u00a0for composing\u00a0todo lists on top of the alga library and will\u00a0show how it can be … Continue reading Graphs in disguise: from todo lists to build systems<\/span> →<\/span><\/a><\/p>\n","protected":false},"author":1174,"featured_media":0,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[6,10],"tags":[13,4],"class_list":["post-468","post","type-post","status-publish","format-standard","hentry","category-coding","category-math","tag-algebra","tag-haskell"],"_links":{"self":[{"href":"https:\/\/blogs.ncl.ac.uk\/andreymokhov\/wp-json\/wp\/v2\/posts\/468","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/blogs.ncl.ac.uk\/andreymokhov\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/blogs.ncl.ac.uk\/andreymokhov\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/blogs.ncl.ac.uk\/andreymokhov\/wp-json\/wp\/v2\/users\/1174"}],"replies":[{"embeddable":true,"href":"https:\/\/blogs.ncl.ac.uk\/andreymokhov\/wp-json\/wp\/v2\/comments?post=468"}],"version-history":[{"count":30,"href":"https:\/\/blogs.ncl.ac.uk\/andreymokhov\/wp-json\/wp\/v2\/posts\/468\/revisions"}],"predecessor-version":[{"id":623,"href":"https:\/\/blogs.ncl.ac.uk\/andreymokhov\/wp-json\/wp\/v2\/posts\/468\/revisions\/623"}],"wp:attachment":[{"href":"https:\/\/blogs.ncl.ac.uk\/andreymokhov\/wp-json\/wp\/v2\/media?parent=468"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/blogs.ncl.ac.uk\/andreymokhov\/wp-json\/wp\/v2\/categories?post=468"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/blogs.ncl.ac.uk\/andreymokhov\/wp-json\/wp\/v2\/tags?post=468"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}
The\u00a0current implementation has two issues<\/a>: the topological sort is not always lexicographically first, as evidenced by cmdLine3<\/code><\/strong> above, where \"-o\"<\/code><\/strong> precedes \"-c\"<\/code><\/strong> in the final ordering. The second issue is that\u00a0topSort<\/code><\/strong> does not satisfy\u00a0the closure axiom<\/em> defined in the previous blog post<\/a>.\u00a0One possible approach\u00a0to fix this is to compute the transitive reduction<\/em><\/a> of the underlying dependency graph before the topological sort.<\/p>\n
Build systems are regularly\u00a0refactored, and it is useful\u00a0to track changes in a build system to automatically rebuild affected files if need be (for example, in the new GHC build system Hadrian<\/a> we track changes in command lines and this helps a lot in its development).\u00a0Some changes do not\u00a0change the semantics of a build system and can therefore be safely ignored. As an example, one can rewrite cmdLine1<\/code><\/strong> defined above by swapping the source and object file parts of the command line:<\/p>\n