The Stack Overflow podcast is back! Listen to an interview with our new CEO.
3 added some editx.
source | link

So I am new to design patterns and C++11, but I have been studying both quite a bit. I am working on developing a C++ application to process some data, and I was hoping that someone with more experience could tell me if I am on the right track.

So the application will take in a large 2-D array of data. Then there is some preprocessing before passing the data to an object that will process the data. Finally, the results of the processing have to be post-processed to set up different types of plots and summary info.

So in studying the design patterns I saw that using the Command pattern or Strategy pattern might be a good fit. But at the same time, seems like I should use the Composite as a way to tie together the preprocessing, processing, and post processing. But I was concerned that tying together 3 objects into a composite might make a very large object--meaning that I would violate separation of concerns type rules.

The reason I want to use a design pattern is because I want a flexible way to add new type of preprocessing, processings, and post-processing chains to the application. So if today I produce one set of charts from the analysis, tomorrow there might be a new chart that someone wants. So I would need a way to add new types of requests or processing chains, without going in and breaking existing objects--which defeats the purpose of OOP design.

Any design tips would be appreciated.

EDIT Note, this question is distinct from: Choosing the right Design Pattern

The reference questions is a general questions about software design approaches. The questions I pose asks for a specific design recommendation based upon a set of requirements.

So I am new to design patterns and C++11, but I have been studying both quite a bit. I am working on developing a C++ application to process some data, and I was hoping that someone with more experience could tell me if I am on the right track.

So the application will take in a large 2-D array of data. Then there is some preprocessing before passing the data to an object that will process the data. Finally, the results of the processing have to be post-processed to set up different types of plots and summary info.

So in studying the design patterns I saw that using the Command pattern or Strategy pattern might be a good fit. But at the same time, seems like I should use the Composite as a way to tie together the preprocessing, processing, and post processing. But I was concerned that tying together 3 objects into a composite might make a very large object--meaning that I would violate separation of concerns type rules.

The reason I want to use a design pattern is because I want a flexible way to add new type of preprocessing, processings, and post-processing chains to the application. So if today I produce one set of charts from the analysis, tomorrow there might be a new chart that someone wants. So I would need a way to add new types of requests or processing chains, without going in and breaking existing objects--which defeats the purpose of OOP design.

Any design tips would be appreciated.

So I am new to design patterns and C++11, but I have been studying both quite a bit. I am working on developing a C++ application to process some data, and I was hoping that someone with more experience could tell me if I am on the right track.

So the application will take in a large 2-D array of data. Then there is some preprocessing before passing the data to an object that will process the data. Finally, the results of the processing have to be post-processed to set up different types of plots and summary info.

So in studying the design patterns I saw that using the Command pattern or Strategy pattern might be a good fit. But at the same time, seems like I should use the Composite as a way to tie together the preprocessing, processing, and post processing. But I was concerned that tying together 3 objects into a composite might make a very large object--meaning that I would violate separation of concerns type rules.

The reason I want to use a design pattern is because I want a flexible way to add new type of preprocessing, processings, and post-processing chains to the application. So if today I produce one set of charts from the analysis, tomorrow there might be a new chart that someone wants. So I would need a way to add new types of requests or processing chains, without going in and breaking existing objects--which defeats the purpose of OOP design.

Any design tips would be appreciated.

EDIT Note, this question is distinct from: Choosing the right Design Pattern

The reference questions is a general questions about software design approaches. The questions I pose asks for a specific design recommendation based upon a set of requirements.

2 added 21 characters in body
source | link

So I am new to design patterns and C++11, but I have been studying both quite a bit. I am working on developing a C++ application to process some data, and I was hoping that someone with more experience could tell me if I am on the right track.

So the application will take in a large 2-D array of data. Then there is some preprocessing before passing the data to an object that will process the data. Finally, the results of the processing have to be post-processed to set up different types of plots and summary info.

So in studying the design patterns I saw that using the Command pattern or Strategy pattern might be a good fit. But at the same time, seems like I should use the Composite as a way to tie together the preprocessing, processing, and post processing. But I was concerned that tying together 3 objects into a composite might make a very large object--meaning that I would violate separation of concerns type rules.

The reason I want to use a design pattern is because I want a flexible way to add new type of preprocessing, processings, and post-processing chains to the application. So if today I produce one set of charts from the analysis, tomorrow there might be a new chart that someone wants. So I would need a way to add new types of requests or processing chains, without going in and breaking existing objects--which defeats the purpose of OOP design.

Any design tips would be appreciated.

So I am new to design patterns and C++11, but I have been studying both quite a bit. I am working on developing a C++ application to process some data, and I was hoping that someone with more experience could tell me if I am on the right track.

So the application will take in a large 2-D array of data. Then there is some preprocessing before passing the data to an object that will process the data. Finally, the results of the processing have to be post-processed to set up different types of plots and summary info.

So in studying the design patterns I saw that using the Command pattern or Strategy pattern might be a good fit. But at the same time, seems like I should use the Composite as a way to tie together the preprocessing, processing, and post processing. But I was concerned that tying together 3 objects into a composite might make a very large object--meaning that I would violate separation of concerns type rules.

The reason I want to use a design pattern is because I want a flexible way to add new type of preprocessing, processings, and post-processing chains to the application. So if today I produce one set of charts from the analysis, tomorrow there might be a new chart that someone wants. So I would need a way to add new types of requests, without going in and breaking existing objects--which defeats the purpose of OOP design.

Any design tips would be appreciated.

So I am new to design patterns and C++11, but I have been studying both quite a bit. I am working on developing a C++ application to process some data, and I was hoping that someone with more experience could tell me if I am on the right track.

So the application will take in a large 2-D array of data. Then there is some preprocessing before passing the data to an object that will process the data. Finally, the results of the processing have to be post-processed to set up different types of plots and summary info.

So in studying the design patterns I saw that using the Command pattern or Strategy pattern might be a good fit. But at the same time, seems like I should use the Composite as a way to tie together the preprocessing, processing, and post processing. But I was concerned that tying together 3 objects into a composite might make a very large object--meaning that I would violate separation of concerns type rules.

The reason I want to use a design pattern is because I want a flexible way to add new type of preprocessing, processings, and post-processing chains to the application. So if today I produce one set of charts from the analysis, tomorrow there might be a new chart that someone wants. So I would need a way to add new types of requests or processing chains, without going in and breaking existing objects--which defeats the purpose of OOP design.

Any design tips would be appreciated.

1
source | link

recommend a design pattern for a C++ application that takes some data, processes it, and returns results

So I am new to design patterns and C++11, but I have been studying both quite a bit. I am working on developing a C++ application to process some data, and I was hoping that someone with more experience could tell me if I am on the right track.

So the application will take in a large 2-D array of data. Then there is some preprocessing before passing the data to an object that will process the data. Finally, the results of the processing have to be post-processed to set up different types of plots and summary info.

So in studying the design patterns I saw that using the Command pattern or Strategy pattern might be a good fit. But at the same time, seems like I should use the Composite as a way to tie together the preprocessing, processing, and post processing. But I was concerned that tying together 3 objects into a composite might make a very large object--meaning that I would violate separation of concerns type rules.

The reason I want to use a design pattern is because I want a flexible way to add new type of preprocessing, processings, and post-processing chains to the application. So if today I produce one set of charts from the analysis, tomorrow there might be a new chart that someone wants. So I would need a way to add new types of requests, without going in and breaking existing objects--which defeats the purpose of OOP design.

Any design tips would be appreciated.