ஜாவாஸ்கிரிப்ட் ப்ராக்ஸி ஹேண்ட்லர் செயல்திறன்: குறுக்கீடு மேல்செலவு உகப்பாக்கம்

ஜாவாஸ்கிரிப்ட் ப்ராக்ஸிகள் மெட்டாபுரோகிராமிங்கிற்கு ஒரு சக்திவாய்ந்த வழிமுறையை வழங்குகின்றன, இது டெவலப்பர்களை அடிப்படை ஆப்ஜெக்ட் செயல்பாடுகளை இடைமறிக்கவும் தனிப்பயனாக்கவும் அனுமதிக்கிறது. இந்த திறன் தரவு சரிபார்ப்பு, மாற்றத்தைக் கண்காணித்தல் மற்றும் சோம்பேறி ஏற்றுதல் (lazy loading) போன்ற மேம்பட்ட வடிவங்களைத் திறக்கிறது. இருப்பினும், குறுக்கீட்டின் தன்மையே செயல்திறன் மேல்செலவை அறிமுகப்படுத்துகிறது. ப்ராக்ஸிகளை திறம்பட பயன்படுத்தும் செயல்திறன் மிக்க பயன்பாடுகளை உருவாக்க, இந்த மேல்செலவைப் புரிந்துகொண்டு தணிப்பது மிகவும் முக்கியம்.

ஜாவாஸ்கிரிப்ட் ப்ராக்ஸிகளைப் புரிந்துகொள்ளுதல்

ஒரு ப்ராக்ஸி ஆப்ஜெக்ட் மற்றொரு ஆப்ஜெக்ட்டை (இலக்கு) சூழ்ந்து, அந்த இலக்கில் செய்யப்படும் செயல்பாடுகளை இடைமறிக்கிறது. இந்த இடைமறிக்கப்பட்ட செயல்பாடுகள் எவ்வாறு கையாளப்படுகின்றன என்பதை ப்ராக்ஸி ஹேண்ட்லர் வரையறுக்கிறது. அடிப்படை தொடரியல் ஒரு இலக்கு ஆப்ஜெக்ட் மற்றும் ஒரு ஹேண்ட்லர் ஆப்ஜெக்டுடன் ஒரு ப்ராக்ஸி நிகழ்வை உருவாக்குவதை உள்ளடக்கியது.

எடுத்துக்காட்டு: அடிப்படை ப்ராக்ஸி

            
const target = { name: 'John Doe' };
const handler = {
  get: function(target, prop, receiver) {
    console.log(`Getting property ${prop}`);
    return Reflect.get(target, prop, receiver);
  },
  set: function(target, prop, value, receiver) {
    console.log(`Setting property ${prop} to ${value}`);
    return Reflect.set(target, prop, value, receiver);
  }
};

const proxy = new Proxy(target, handler);

console.log(proxy.name); // Output: Getting property name, John Doe
proxy.age = 30;          // Output: Setting property age to 30
console.log(target.age); // Output: 30

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `proxy` ஆப்ஜெக்ட்டில் ஒரு பண்பை அணுக அல்லது மாற்றும் ஒவ்வொரு முயற்சியும் முறையே `get` அல்லது `set` ஹேண்ட்லரைத் தூண்டுகிறது. `Reflect` API அசல் இலக்கு ஆப்ஜெக்ட்டிற்கு செயல்பாட்டை அனுப்ப ஒரு வழியை வழங்குகிறது, இயல்புநிலை நடத்தை பராமரிக்கப்படுவதை உறுதி செய்கிறது.

ப்ராக்ஸி ஹேண்ட்லர்களின் செயல்திறன் மேல்செலவு

ப்ராக்ஸிகளுடனான முக்கிய செயல்திறன் சவால், சேர்க்கப்பட்ட மறைமுக அடுக்கிலிருந்து உருவாகிறது. ப்ராக்ஸி ஆப்ஜெக்ட்டில் உள்ள ஒவ்வொரு செயல்பாடும் ஹேண்ட்லர் செயல்பாடுகளை இயக்குவதை உள்ளடக்கியது, இது CPU சுழற்சிகளைப் பயன்படுத்துகிறது. இந்த மேல்செலவின் தீவிரம் பல காரணிகளைப் பொறுத்தது:

• ஹேண்ட்லர் செயல்பாடுகளின் சிக்கலான தன்மை: ஹேண்ட்லர் செயல்பாடுகளுக்குள் உள்ள தர்க்கம் எவ்வளவு சிக்கலானதாக இருக்கிறதோ, அவ்வளவு அதிகமாக மேல்செலவு இருக்கும்.
• இடைமறிக்கப்பட்ட செயல்பாடுகளின் அதிர்வெண்: ஒரு ப்ராக்ஸி அதிக எண்ணிக்கையிலான செயல்பாடுகளை இடைமறித்தால், ஒட்டுமொத்த மேல்செலவு குறிப்பிடத்தக்கதாகிறது.
• ஜாவாஸ்கிரிப்ட் இயந்திரத்தின் செயலாக்கம்: வெவ்வேறு ஜாவாஸ்கிரிப்ட் இயந்திரங்கள் (எ.கா., V8, SpiderMonkey, JavaScriptCore) ப்ராக்ஸி உகப்பாக்கத்தின் வெவ்வேறு நிலைகளைக் கொண்டிருக்கலாம்.

ஒரு ஆப்ஜெக்ட்டில் தரவு எழுதப்படுவதற்கு முன்பு அதைச் சரிபார்க்க ப்ராக்ஸி பயன்படுத்தப்படும் ஒரு சூழ்நிலையைக் கவனியுங்கள். இந்த சரிபார்ப்பில் சிக்கலான வழக்கமான கோவைகள் அல்லது வெளிப்புற API அழைப்புகள் இருந்தால், மேல்செலவு கணிசமானதாக இருக்கலாம், குறிப்பாக தரவு அடிக்கடி புதுப்பிக்கப்பட்டால்.

ப்ராக்ஸி ஹேண்ட்லர் செயல்திறனை உகப்பாக்குவதற்கான உத்திகள்

ஜாவாஸ்கிரிப்ட் ப்ராக்ஸி ஹேண்ட்லர்களுடன் தொடர்புடைய செயல்திறன் மேல்செலவைக் குறைக்க பல உத்திகளைக் கையாளலாம்:

1. ஹேண்ட்லர் சிக்கலான தன்மையைக் குறைத்தல்

மேல்செலவைக் குறைப்பதற்கான மிக நேரடியான வழி, ஹேண்ட்லர் செயல்பாடுகளுக்குள் உள்ள தர்க்கத்தை எளிதாக்குவதாகும். தேவையற்ற கணக்கீடுகள், சிக்கலான தரவு கட்டமைப்புகள் மற்றும் வெளிப்புற சார்புகளைத் தவிர்க்கவும். செயல்திறன் தடைகளைக் கண்டறிந்து அதற்கேற்ப அவற்றை உகப்பாக்க உங்கள் ஹேண்ட்லர் செயல்பாடுகளை சுயவிவரப்படுத்துங்கள்.

எடுத்துக்காட்டு: தரவு சரிபார்ப்பை உகப்பாக்குதல்

ஒவ்வொரு பண்பு அமைப்பிலும் சிக்கலான, நிகழ்நேர சரிபார்ப்பைச் செய்வதற்குப் பதிலாக, குறைந்த செலவிலான பூர்வாங்கச் சரிபார்ப்பைப் பயன்படுத்துவதையும், முழு சரிபார்ப்பையும் பிற்கால நிலைக்கு, அதாவது தரவுத்தளத்தில் தரவைச் சேமிப்பதற்கு முன்பு ஒத்திவைப்பதையும் கருத்தில் கொள்ளுங்கள்.

            
const target = {};
const handler = {
  set: function(target, prop, value) {
    // Simple type check (example)
    if (typeof value !== 'string') {
      console.warn(`Invalid value for property ${prop}: ${value}`);
      return false; // Prevent setting the value
    }

    target[prop] = value;
    return true;
  }
};

const proxy = new Proxy(target, handler);

            

              
                Copy
              
            
          

இந்த உகப்பாக்கப்பட்ட எடுத்துக்காட்டு ஒரு அடிப்படை வகை சரிபார்ப்பைச் செய்கிறது. மிகவும் சிக்கலான சரிபார்ப்பை ஒத்திவைக்கலாம்.

2. இலக்கு குறுக்கீட்டைப் பயன்படுத்துதல்

அனைத்து செயல்பாடுகளையும் இடைமறிப்பதற்குப் பதிலாக, தனிப்பயன் நடத்தை தேவைப்படும் செயல்பாடுகளை மட்டும் இடைமறிப்பதில் கவனம் செலுத்துங்கள். எடுத்துக்காட்டாக, குறிப்பிட்ட பண்புகளில் ஏற்படும் மாற்றங்களை மட்டும் நீங்கள் கண்காணிக்க வேண்டும் என்றால், அந்த பண்புகளுக்கான `set` செயல்பாடுகளை மட்டும் இடைமறிக்கும் ஒரு ஹேண்ட்லரை உருவாக்கவும்.

எடுத்துக்காட்டு: இலக்கு பண்பு கண்காணிப்பு

            
const target = { name: 'John Doe', age: 30 };
const trackedProperties = new Set(['age']);
const handler = {
  set: function(target, prop, value) {
    if (trackedProperties.has(prop)) {
      console.log(`Property ${prop} changed from ${target[prop]} to ${value}`);
    }
    target[prop] = value;
    return true;
  }
};

const proxy = new Proxy(target, handler);

proxy.name = 'Jane Doe'; // No log
proxy.age = 31;          // Output: Property age changed from 30 to 31

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `age` பண்பில் ஏற்படும் மாற்றங்கள் மட்டுமே பதிவு செய்யப்படுகின்றன, இது மற்ற பண்பு ஒதுக்கீடுகளுக்கான மேல்செலவைக் குறைக்கிறது.

3. ப்ராக்ஸிகளுக்கு மாற்றுகளைக் கருத்தில் கொள்ளுங்கள்

ப்ராக்ஸிகள் சக்திவாய்ந்த மெட்டாபுரோகிராமிங் திறன்களை வழங்கினாலும், அவை எப்போதும் செயல்திறன் மிக்க தீர்வாக இருப்பதில்லை. நேரடி பண்பு அணுகிகள் (getters and setters) அல்லது தனிப்பயன் நிகழ்வு அமைப்புகள் போன்ற மாற்று அணுகுமுறைகள், விரும்பிய செயல்பாட்டை குறைந்த மேல்செலவுடன் அடைய முடியுமா என்பதை மதிப்பீடு செய்யுங்கள்.

எடுத்துக்காட்டு: கெட்டர்கள் மற்றும் செட்டர்களைப் பயன்படுத்துதல்

            
class Person {
  constructor(name, age) {
    this._name = name;
    this._age = age;
  }

  get name() {
    return this._name;
  }

  set name(value) {
    console.log(`Name changed to ${value}`);
    this._name = value;
  }

  get age() {
    return this._age;
  }

  set age(value) {
    if (value < 0) {
      throw new Error('Age cannot be negative');
    }
    this._age = value;
  }
}

const person = new Person('John Doe', 30);
person.name = 'Jane Doe'; // Output: Name changed to Jane Doe

try {
  person.age = -10; // Throws an error
} catch (error) {
  console.error(error.message);
}

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், கெட்டர்கள் மற்றும் செட்டர்கள் ப்ராக்ஸிகளின் மேல்செலவு இல்லாமல் பண்பு அணுகல் மற்றும் மாற்றத்தின் மீது கட்டுப்பாட்டை வழங்குகின்றன. குறுக்கீடு தர்க்கம் ஒப்பீட்டளவில் எளிமையானதாகவும், தனிப்பட்ட பண்புகளுக்கு குறிப்பிட்டதாகவும் இருக்கும்போது இந்த அணுகுமுறை பொருத்தமானது.

4. டிபவுன்சிங் மற்றும் த்ராட்லிங்

உங்கள் ப்ராக்ஸி ஹேண்ட்லர் உடனடியாக செயல்படுத்தத் தேவையில்லாத செயல்களைச் செய்தால், ஹேண்ட்லர் அழைப்புகளின் அதிர்வெண்ணைக் குறைக்க டிபவுன்சிங் அல்லது த்ராட்லிங் நுட்பங்களைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள். பயனர் உள்ளீடு அல்லது அடிக்கடி தரவு புதுப்பிப்புகளை உள்ளடக்கிய காட்சிகளுக்கு இது குறிப்பாக பயனுள்ளதாக இருக்கும்.

எடுத்துக்காட்டு: ஒரு சரிபார்ப்பு செயல்பாட்டை டிபவுன்ஸ் செய்தல்

            
function debounce(func, delay) {
  let timeoutId;
  return function(...args) {
    clearTimeout(timeoutId);
    timeoutId = setTimeout(() => {
      func.apply(this, args);
    }, delay);
  };
}

const target = {};
const handler = {
  set: function(target, prop, value) {
    const validate = debounce(() => {
      console.log(`Validating ${prop}: ${value}`);
      // Perform validation logic here
    }, 250); // Debounce for 250 milliseconds
    target[prop] = value;
    validate();
    return true;
  }
};

const proxy = new Proxy(target, handler);

proxy.name = 'John';
proxy.name = 'Johnny';
proxy.name = 'Johnathan'; // Validation will only run after 250ms of inactivity

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `validate` செயல்பாடு டிபவுன்ஸ் செய்யப்பட்டுள்ளது, `name` பண்பு விரைவாக பலமுறை புதுப்பிக்கப்பட்டாலும், ஒரு குறிப்பிட்ட செயலற்ற காலத்திற்குப் பிறகு அது ஒரு முறை மட்டுமே செயல்படுத்தப்படுவதை உறுதி செய்கிறது.

5. முடிவுகளை கேச்சிங் செய்தல்

உங்கள் ஹேண்ட்லர் ஒரே உள்ளீட்டிற்கு ஒரே முடிவை உருவாக்கும் கணக்கீட்டு ரீதியாக விலையுயர்ந்த செயல்பாடுகளைச் செய்தால், தேவையற்ற கணக்கீடுகளைத் தவிர்க்க முடிவுகளை கேச்சிங் செய்வதைக் கருத்தில் கொள்ளுங்கள். முன்பு கணக்கிடப்பட்ட மதிப்புகளைச் சேமித்து மீட்டெடுக்க எளிய கேச் ஆப்ஜெக்ட் அல்லது மிகவும் அதிநவீன கேச்சிங் நூலகத்தைப் பயன்படுத்தவும்.

எடுத்துக்காட்டு: API பதில்களை கேச்சிங் செய்தல்

            
const cache = {};
const target = {};
const handler = {
  get: async function(target, prop) {
    if (cache[prop]) {
      console.log(`Fetching ${prop} from cache`);
      return cache[prop];
    }

    console.log(`Fetching ${prop} from API`);
    const response = await fetch(`/api/${prop}`); // Replace with your API endpoint
    const data = await response.json();
    cache[prop] = data;
    return data;
  }
};

const proxy = new Proxy(target, handler);

(async () => {
  console.log(await proxy.users); // Fetches from API
  console.log(await proxy.users); // Fetches from cache
})();

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டில், `users` பண்பு ஒரு API இலிருந்து பெறப்படுகிறது. பதில் கேச் செய்யப்படுகிறது, எனவே அடுத்தடுத்த அணுகல்கள் மற்றொரு API அழைப்பைச் செய்வதற்குப் பதிலாக கேச்சிலிருந்து தரவை மீட்டெடுக்கின்றன.

6. மாற்றமுடியாமை மற்றும் கட்டமைப்பு பகிர்வு

சிக்கலான தரவு கட்டமைப்புகளைக் கையாளும்போது, மாற்றமுடியாத தரவு கட்டமைப்புகள் மற்றும் கட்டமைப்பு பகிர்வு நுட்பங்களைப் பயன்படுத்துவதைக் கருத்தில் கொள்ளுங்கள். மாற்றமுடியாத தரவு கட்டமைப்புகள் இடத்தில் மாற்றியமைக்கப்படுவதில்லை; பதிலாக, மாற்றங்கள் புதிய தரவு கட்டமைப்புகளை உருவாக்குகின்றன. கட்டமைப்பு பகிர்வு இந்த புதிய தரவு கட்டமைப்புகளை அசல் தரவு அமைப்புடன் பொதுவான பகுதிகளைப் பகிர்ந்து கொள்ள அனுமதிக்கிறது, நினைவக ஒதுக்கீடு மற்றும் நகலெடுப்பதைக் குறைக்கிறது. Immutable.js மற்றும் Immer போன்ற நூலகங்கள் மாற்றமுடியாத தரவு கட்டமைப்புகள் மற்றும் கட்டமைப்பு பகிர்வு திறன்களை வழங்குகின்றன.

எடுத்துக்காட்டு: ப்ராக்ஸிகளுடன் இம்மரைப் பயன்படுத்துதல்

            
import { produce } from 'immer';

const baseState = { name: 'John Doe', address: { street: '123 Main St' } };

const handler = {
  set: function(target, prop, value) {
    const nextState = produce(target, draft => {
      draft[prop] = value;
    });
    // Replace the target object with the new immutable state
    Object.assign(target, nextState);
    return true;
  }
};

const proxy = new Proxy(baseState, handler);

proxy.name = 'Jane Doe'; // Creates a new immutable state
console.log(baseState.name); // Output: Jane Doe

            

              
                Copy
              
            
          

இந்த எடுத்துக்காட்டு ஒரு பண்பு மாற்றியமைக்கப்படும் போதெல்லாம் மாற்றமுடியாத நிலைகளை உருவாக்க இம்மரைப் பயன்படுத்துகிறது. ப்ராக்ஸி செட் செயல்பாட்டை இடைமறித்து, ஒரு புதிய மாற்றமுடியாத நிலையை உருவாக்குகிறது. இது மிகவும் சிக்கலானதாக இருந்தாலும், நேரடி மாற்றத்தைத் தவிர்க்கிறது.

7. ப்ராக்ஸி ரத்து செய்தல்

ஒரு ப்ராக்ஸி இனி தேவைப்படாவிட்டால், அதனுடன் தொடர்புடைய வளங்களை விடுவிக்க அதை ரத்து செய்யுங்கள். ஒரு ப்ராக்ஸியை ரத்து செய்வது ப்ராக்ஸி மூலம் இலக்கு ஆப்ஜெக்ட்டுடன் மேலும் தொடர்புகளைத் தடுக்கிறது. `Proxy.revocable()` முறை ரத்துசெய்யக்கூடிய ப்ராக்ஸியை உருவாக்குகிறது, இது ஒரு `revoke()` செயல்பாட்டை வழங்குகிறது.

எடுத்துக்காட்டு: ஒரு ப்ராக்ஸியை ரத்து செய்தல்

            
const { proxy, revoke } = Proxy.revocable({}, {
  get: function(target, prop) {
    return 'Hello';
  }
});

console.log(proxy.message); // Output: Hello

revoke();

try {
  console.log(proxy.message); // Throws a TypeError
} catch (error) {
  console.error(error.message); // Output: Cannot perform 'get' on a proxy that has been revoked
}

            

              
                Copy
              
            
          

ஒரு ப்ராக்ஸியை ரத்து செய்வது வளங்களை விடுவிக்கிறது மற்றும் மேலும் அணுகலைத் தடுக்கிறது, இது நீண்டகாலமாக இயங்கும் பயன்பாடுகளில் மிகவும் முக்கியமானது.

ப்ராக்ஸி செயல்திறனை அளவிடுதல் மற்றும் சுயவிவரப்படுத்துதல்

ப்ராக்ஸி ஹேண்ட்லர்களின் செயல்திறன் தாக்கத்தை மதிப்பிடுவதற்கான மிகவும் பயனுள்ள வழி, உங்கள் குறியீட்டை ஒரு யதார்த்தமான சூழலில் அளவிடுதல் மற்றும் சுயவிவரப்படுத்துதல் ஆகும். வெவ்வேறு குறியீடு பாதைகளின் செயல்படுத்தும் நேரத்தை அளவிட Chrome DevTools, Node.js Inspector அல்லது பிரத்யேக அளவீட்டு நூலகங்கள் போன்ற செயல்திறன் சோதனை கருவிகளைப் பயன்படுத்தவும். ஹேண்ட்லர் செயல்பாடுகளில் செலவழித்த நேரத்தைக் கவனித்து, உகப்பாக்கத்திற்கான பகுதிகளைக் கண்டறியவும்.

எடுத்துக்காட்டு: சுயவிவரப்படுத்தலுக்கு Chrome DevTools-ஐப் பயன்படுத்துதல்

1. Chrome DevTools-ஐத் திறக்கவும் (Ctrl+Shift+I அல்லது Cmd+Option+I).
2. "Performance" தாவலுக்குச் செல்லவும்.
3. ரெக்கார்டு பொத்தானைக் கிளிக் செய்து, ப்ராக்ஸிகளைப் பயன்படுத்தும் உங்கள் குறியீட்டை இயக்கவும்.
4. பதிவு செய்வதை நிறுத்தவும்.
5. உங்கள் ஹேண்ட்லர் செயல்பாடுகளில் செயல்திறன் தடைகளைக் கண்டறிய ஃபிளேம் விளக்கப்படத்தை பகுப்பாய்வு செய்யவும்.

முடிவுரை

ஜாவாஸ்கிரிப்ட் ப்ராக்ஸிகள் ஆப்ஜெக்ட் செயல்பாடுகளை இடைமறிக்கவும் தனிப்பயனாக்கவும் ஒரு சக்திவாய்ந்த வழியை வழங்குகின்றன, இது மேம்பட்ட மெட்டாபுரோகிராமிங் வடிவங்களை செயல்படுத்துகிறது. இருப்பினும், உள்ளார்ந்த குறுக்கீடு மேல்செலவுக்கு கவனமான பரிசீலனை தேவை. ஹேண்ட்லர் சிக்கலான தன்மையைக் குறைத்தல், இலக்கு குறுக்கீட்டைப் பயன்படுத்துதல், மாற்று அணுகுமுறைகளை ஆராய்தல், மற்றும் டிபவுன்சிங், கேச்சிங், மற்றும் மாற்றமுடியாமை போன்ற நுட்பங்களைப் பயன்படுத்துவதன் மூலம், நீங்கள் ப்ராக்ஸி ஹேண்ட்லர் செயல்திறனை உகப்பாக்கி, இந்த சக்திவாய்ந்த அம்சத்தை திறம்பட பயன்படுத்தும் செயல்திறன் மிக்க பயன்பாடுகளை உருவாக்கலாம்.

செயல்திறன் தடைகளைக் கண்டறிந்து உங்கள் உகப்பாக்க உத்திகளின் செயல்திறனைச் சரிபார்க்க உங்கள் குறியீட்டை அளவிடவும் சுயவிவரப்படுத்தவும் நினைவில் கொள்ளுங்கள். உற்பத்தி சூழல்களில் உகந்த செயல்திறனை உறுதிசெய்ய உங்கள் ப்ராக்ஸி ஹேண்ட்லர் செயலாக்கங்களைத் தொடர்ந்து கண்காணித்து செம்மைப்படுத்தவும். கவனமான திட்டமிடல் மற்றும் உகப்பாக்கத்துடன், ஜாவாஸ்கிரிப்ட் ப்ராக்ஸிகள் வலுவான மற்றும் பராமரிக்கக்கூடிய பயன்பாடுகளை உருவாக்குவதற்கான ஒரு மதிப்புமிக்க கருவியாக இருக்க முடியும்.

மேலும், சமீபத்திய ஜாவாஸ்கிரிப்ட் இயந்திர உகப்பாக்கங்களுடன் புதுப்பித்த நிலையில் இருங்கள். நவீன இயந்திரங்கள் தொடர்ந்து உருவாகி வருகின்றன, மேலும் ப்ராக்ஸி செயலாக்கங்களில் ஏற்படும் மேம்பாடுகள் செயல்திறனை கணிசமாக பாதிக்கலாம். இந்த முன்னேற்றங்களைப் பயன்படுத்திக்கொள்ள உங்கள் ப்ராக்ஸி பயன்பாடு மற்றும் உகப்பாக்க உத்திகளை அவ்வப்போது மறு மதிப்பீடு செய்யுங்கள்.

இறுதியாக, உங்கள் பயன்பாட்டின் பரந்த கட்டமைப்பைக் கருத்தில் கொள்ளுங்கள். சில நேரங்களில், ப்ராக்ஸி ஹேண்ட்லர் செயல்திறனை உகப்பாக்குவது, குறுக்கீட்டின் தேவையை முதலில் குறைக்க ஒட்டுமொத்த வடிவமைப்பை மறுபரிசீலனை செய்வதை உள்ளடக்கியது. நன்கு வடிவமைக்கப்பட்ட ஒரு பயன்பாடு தேவையற்ற சிக்கல்களைக் குறைத்து, முடிந்தவரை எளிய, திறமையான தீர்வுகளை நம்பியுள்ளது.