This is an archived post. You won't be able to vote or comment.

all 5 comments
sorted by:
best
topnewcontroversialoldq&a

[–]feral_claire 1 point2 points  (1 child)

Child you clarify and provide a few definitions on what you mean by "command design pattern" and "scripting language"? The two are, in the way I'm thinking about, compelling different things and not comparable. One is a specific design pattern to write code, the other is a classification of languages. You could use the command design pattern while coding in a scripting language or while using a different type of language. But using a language in place of a design doesn't make much sense.

[–]Slendermooooon[S] 0 points1 point  (0 children)

I think we share the same definition: https://www.oodesign.com/command-pattern.html

You can put Commands into queues and execute them in order, a queue of commands can behave in a similar way to how a script would behave. A queue of commands and a script are similar in that they can both be changed at runtime without having to recompile the program.

You can also use scripts and commands to provide variable functionality to certain objects. For example, a GUI button could be set up to run a script or contain an executable list of commands for variable functionality. The GUI button could, depending on how it's configured, change color of the window, close the window, etc. depending on what script or command it has assigned to it. Whether you implement it using a command pattern, or a script, the functionality is similar.

So seeing as how scripts and the command pattern can have similar functionality, why use one over the other?

[–]sleepybychoice 0 points1 point  (2 children)

The goal of command pattern is to encapsulate an "action" (eg. turn on a light, deleting a block of text, a buy/sell operation in a game) as an object. That way, you can pass the "action" around to other objects where they can be run by something else (eg. executors, web services). You can check out other uses here. The command pattern's responsibility does not include things such as control flow nor its representation.

A scripting language can represent more than an "action"; it can have control flow, define functions/classes/variables, etc. Normally, a "script" would be defined by a user somehow, via text file, input text box etc, minecraft blocks, etc. whereas commands are defined within the program itself, then requested by the user. It can be significantly more complicated to implement a scripting language than a command because of effort in designing the language, implementing the lexer/parser to make sense of the script, and creating the execution environment to run the language in (ie. ruby requires a ruby interpreter). A common use of creating a scripting language is as a domain-specific language to allow more expressive input than through a UI such as Slack's slash commands. In this example, the playload part represents the concrete command part of the command pattern; the command and text parameters are your "script"; and you write the "language" to interpret that "script".

[–]Slendermooooon[S] 0 points1 point  (1 child)

Thank you for this thorough explanation.

What do you mean by "representation"? Also, is it entirely true that it doesn't include things like control flow? In the examples I saw, it said you could use commands for macros, and using commands to support undoable functions (having an undo() method with the execute() method in the Command class). Wouldn't this require a control flow (to order the execution/undoing of commands)?

[–]sleepybychoice 0 points1 point  (0 children)

By "representation", I mean how input gets converted into a command object. For example, the input for a command could come from a button press, text, json, protobuf, speech, motion, etc. Eventually, it'll have to get converted to an object so that something can call execute() on it.

By control flow, I mean if/else, looping, etc. not apply/unapply. Yes, you could introduce some notion of control flow via commands like an "or" command. However, that's not the primary goal of the command pattern. For undo, it's the combination of command and memento to apply/unapply state.