code-duplication

I am using JSch library for SFTP. I need to do several operations on SFTP server like move remote files in other directory, pull files, etc. For all these operations I need Session and from it I get Channel an then cast it to ChannelSftp . This is redundant step. So I thought of abstracting it into a private method. private ChannelSftp getChannelSftp() throws JSchException { java.util.Properties config = new java.util.Properties(); config.put("StrictHostKeyChecking", "no"); JSch jsch = new JSch(); Session session; session = jsch.getSession(VENDOR1_USERID, VENDOR1_SERVER, VENDOR1_PORT); session

Similarly to How do I remove code duplication between similar const and non-const member functions? , I want to remove the code duplication between nearly identical member functions, except for ref qualifiers. Let's say I have a class that's something like this: class MyStringBuilder { std::string member; public: // Other functions std::string create() const& { // Some work std::string result = member; // More work return result; } std::string create() && { // Some work std::string result = std::move(member); // More work return result; } }; It's not inconceivable that we would want to do this

I have policies that derive from a base policy. Some classes specialize for the derived policies while others specialize only for the base policy and can work with all derived policies. The problem I am running into is too much code-duplication (mainly constructors and some boiler plate code for the class itself). The code below may provide a better explanation of what I mean: struct BasePolicy {}; struct DerivedPolicy1 : public BasePolicy {}; struct DerivedPolicy2 : public BasePolicy {}; //... more policies deriving from BasePolicy (or other BasePolicies) struct AnotherPolicy {}; template

I've got a question concerning code duplication and refactoring, hope it's not too general. Say you've got a rather small piece of code (~5 lines) which is a sequence of function invocations that is - not a very low level . This code is repeated in several places, so it would probably be a good idea to extract a method here. However, in this particular example, this new function would suffer from low cohesion (which manifests itself, among others, by having a hard time finding a good name for the function). The reason for that is probably because this repeated code is just a part of a bigger

I've been going through some Assembly Programming Videos to get a better understanding of how to manually optimize the *.s files left after compiling with gcc/g++ -S ... One of the topics covered was Refactoring Redundant Code that demonstrates how to move redundant code to its own labeled block ending with a ret and replacing it with a call . The example given in the video is 2 blocks containing: mov eax,power mul ebx mov power,eax inc count which it replaces with call CalculateNextPower and CalculateNextPower looks like: CalculateNextPower: mov eax,power mul ebx mov power,eax inc count ret