Netbeans/C2/Netbeans-Debugger/Malayalam

From Script | Spoken-Tutorial
Jump to: navigation, search


Time Narration
00:01 ഹലോ എല്ലാവ൪കു൦Netbeans Debugger. ട്യൂട്ടോറിയലിലേക്ക് സ്വാഗതം.
00:06 നിങ്ങൾ ആദ്യതവണ ആണ് Netbeans, ഉപയോഗിക്കുന്നതെങ്കിൽ, ദയവായി Spoken Tutorial വെബ്സൈറ്റിലെ മുൻ ട്യൂട്ടോറിയലുകൾ കാണുക.
00:14 ഈ പ്രകടനത്തിനായി, ഞാൻ Linux Operating System Ubuntu പതിപ്പ് '12 .04'
00:21 ഉ൦ Netbeans IDE പതിപ്പ് 7.1.1.
00:26 ഡീബഗ്ഗിംഗ് പ്രോഗ്രാമുകൾ വളരെ ബുദ്ധിമുട്ടുള്ള ഒരു ചുമതലയായിരിക്കുമെന്ന് നമുക്കറിയാം.
00:31 അതിനാൽ, ഒരു ഡീബഗ്ഗിംഗ് ഉപകരണം അറിയുകയും അതിന്റെ സവിശേഷതകളുമായി പരിചിതരാകുന്നത് വിലപ്പെട്ട സമയം ലാഭിക്കാൻ സഹായിക്കും.
00:39 ഈ ശക്തമായ ഡീബഗ്ഗിംഗ് പ്രയോഗം വളരെ ഉപകാരപ്രദമാണു്,
00:42 പ്രത്യേകിച്ച് നിങ്ങൾക്ക് വലിയ പ്രോഗ്രാമുകൾ കോഡും ടെസ്റ്റ് ചെയ്യേണ്ടിവരും.
00:46 Netbeans Debuggerലഭ്യമാക്കുന്ന ചില ഫീച്ചറുകൾ നമുക്ക് ഈ ട്യൂട്ടോറിയലിൽ പഠിക്കാം.
00:53 ഈ ട്യൂട്ടോറിയൽ നിങ്ങളെ പരിചയപ്പെടുത്തും-
00:55 ഡീബഗ്ഗിംഗ് വിൻഡോ
00:58 breakpoint ക്രമീകരിച്ചു
01:00 എക്സ്പ്രഷൻ മൂല്യനിർണ്ണയം അല്ലെങ്കിൽ വാച്ചുകൾ സജ്ജമാക്കുക
01:04 നിങ്ങളുടെ പ്രോഗ്രാം എക്സിക്യൂഷൻ കണ്ടെത്താനുള്ള ഓപ്ഷനുകളും
01:07 ഓപ്ഷനുകൾ configure debugger തന്നെയാണ്.
01:12 ഇനി നമുക്ക് ആരംഭിക്കാം, 'ഈ സാമ്പിൾcode debug ആണ്.
01:17 Netbeans IDEയിലേക്ക് ഞാൻ പോകും.
01:20 ഈ പ്രകടനത്തിനായി, ഞാൻ ഇതിനകം ഒരു Java അപ്ലിക്കേഷൻ "sampleDebug " എന്റെ IDE യിൽ സൃഷ്ടിച്ചിട്ടുണ്ട്.
01:27 a, b, ഉ൦ cഎന്നീ മൂന്ന് സംഖ്യകൾ ആരംഭിക്കുന്ന ചെറിയൊരു പ്രോഗ്രാമാണിത്.
01:35 പിന്നീട് അത് "Hello World!" ,a എന്നിവ അച്ചടിക്കുന്നു.
01:40 അത് ഒരു class' ഓബ്ജക്റ്റ് SampleClass സൃഷ്ടിക്കുന്നു. ഇതിൽ 'value' integer,private പൂർണ്ണസംഖ്യയായും.
01:52 പിന്നെ, b ന്റെ മൂല്യം കണക്കാക്കുന്നു
01:55 'C' ന്റെ മൂല്യം കണക്കാക്കുന്നതിന് ഒരുfunction
02:00 b, c എന്നീ മൂല്യങ്ങൾ പ്രിന്റ് ചെയ്യുന്നു.
02:05 ഡീബഗ്ഗിങ്ങിനൊപ്പം ആരംഭിക്കുന്നതിന്, നമുക്ക് ആദ്യം break-point എന്നു സജ്ജീകരിക്കാം.
02:09 break point, സജ്ജമാക്കാൻ, ലൈൻ നമ്പറിൽ ക്ലിക്കുചെയ്യുക
02:13 ഞാൻ ഈ വരിയിൽ "Hello World!"പ്രിന്റ് ചെയ്യുന്നു.
02:18 break-pointസെറ്റ് ചെയ്ത വരി, പിങ്ക് നിറത്തിന് മാറുന്നുവെന്നത് ശ്രദ്ധിക്കുക, കൂടാതെ അതിന്റെ വരി സംഖ്യയിൽ ഒരു ചെറിയ സ്ക്വയർ അടയാളപ്പെടുത്തുകയും ചെയ്യുന്നു.
02:28 നിങ്ങൾdebugging മോഡിൽrun ചെയ്യുമ്പോൾ,
02:31 ടൂള് ബാറിലെ Debug Project

ബട്ടണ് ക്ലിക്കുചെയ്ത്,

02:35 breakpoint സ്ഥിതി ചെയ്യുന്ന വരിയിൽ പ്രോഗ്രാം അവസാനിപ്പിക്കുന്നത് നിർത്തുന്നു.
02:41 ഇതുവരെ,a ന്റെ മൂല്യം സജ്ജീകരിച്ചു.
02:45 അതിന്റെ മൂല്യത്തെ പരിശോധിക്കുന്നതിനായി അതിൽ ഹോവർ ചെയ്യുക.
02:49 അത് മൂല്യം 10 ​​ആണ് സൂചിപ്പിക്കുന്നു.
02:52 workspaceഎന്നതിന് താഴെ അധിക വിൻഡോകൾ ഉണ്ട് എന്ന് നിങ്ങൾക്ക് കാണാം.
02:59 ഒരു വേരിയബിളുകളും അവയുടെ മൂല്യങ്ങളും കാണിക്കുന്ന ഒരു 'Variables' ജാലകം ഉണ്ട്.
03:07 ഇതുവരെ, വേരിയബിൾ 'a' ആരംഭിച്ചു.
03:11 സാമ്പിൾ debug 'Output' കൂടിയ വിൻഡോയും നമുക്ക് നോക്കാം.
03:17 ഇതുവരെ ഔട്ട്പുട്ട് ഒന്നും ഇല്ല
03:19 ഒരു a Debugger Console ഉണ്ട്. അവിടെ ലൈബ്രറി 29 ന് ഒരു ബ്രേക്ക് പോയിന്റ് കടന്നുപോയി.
03:28 ഒരു Breakpoints '29' എന്ന ബ്രേക്ക് പോയിന്റ് ക്ലോസ് ചെയ്തതായി 'ബ്രേക്ക് പോയിന്റ്സ്' വിൻഡോയുണ്ട്.
03:36 മുന്നോട്ടു പോകുന്നതിനു watch എങ്ങനെ ചേർക്കാമെന്ന് നമുക്ക് നോക്കാം.
03:40 ഉദാഹരണത്തിന്, ഞാൻ പറയട്ടെ, എനിക്ക് പൂർണ്ണസംഖ്യയുടെ മൂല്യം'aSample' കാണാൻ ആഗ്രഹിക്കുന്നു.
03:48 workspace എന്നതിന് താഴെയുള്ള 'Variables' വിൻഡോയിൽ,Enter new Watch എന്ന ഓപ്ഷനിൽ ഡബിൾ ക്ലിക്ക് ചെയ്ത് "aSample.value" എന്ന വേരിയബിളിന്റെ പേര് നൽകുക
04:02 OK.ക്ലിക്ക് ചെയ്യുക
04:06 ഇതുവരെ, aSample സൃഷ്ടിച്ചതല്ല. അതിനാൽ, അത് മൂല്യം അറിയുന്നില്ലെന്ന് പറയുന്നു.
04:12 ഒരിക്കൽ ഇത് ലൈൻ പ്രവർത്തിപ്പിക്കുമ്പോൾ, എന്താണ് വേരിയബിളിന് ഉള്ളതെന്ന് ഞങ്ങൾക്കറിയാം.
04:16 സമാനമായ രീതിയിൽ നിങ്ങൾക്ക് എക്സ്പ്രഷനുകൾ നിരീക്ഷിക്കാനും വിലയിരുത്താനും കഴിയും.
04:21 ഇവിടെ,b=a+10 ഞാൻ പരിശോധിക്കുന്നു.
04:25 എന്താണ്a-4 എന്നറിയാൻ ഞാൻ ആഗ്രഹിച്ചതാണെങ്കിൽ.
04:29 അതിനാല്, മെനു ബാറിലെDebug മെനുവില് പോയി Evaluate expression ഓപ്ഷന് തിരഞ്ഞെടുക്കുക.
04:37 'Evaluate Code' ജാലകം വർക്ക്സ്പെയ്സിൽ കാണാം.
04:41 ഇവിടെ, 'a-4' എന്ന പ്രയോഗത്തിൽ ഞാൻ പ്രവേശിക്കും.
04:45 Variable വിൻഡോയിൽ Evaluate Expression എന്ന ബട്ടണിൽ ക്ലിക്ക് ചെയ്യുക (a-4) ന്റെ മൂല്യം 6 ആണ്.
04:56 ഇനി നമുക്ക് ഈ കോഡ് ഒറ്റ വരിയിൽ പ്രവർത്തിപ്പിക്കാം.
05:00 ഇതിനായി, ടൂൾബാറിൽ നിന്ന്Step-Overബട്ടൺ തിരഞ്ഞെടുക്കുക.
05:06 Hello World”അച്ചടിക്കാൻ കോഡിന്റെ ഒരേയൊരു വരി മാത്രം പ്രവർത്തിപ്പിക്കണം.
05:12 ഔട്ട്പുട്ട് കാണുന്നതിന്, ഔട്ട്പുട്ട് വിൻഡോയിലേക്ക് പോയി sampleDebugഔട്ട്പുട്ട് വിൻഡോ തിരഞ്ഞെടുക്കുക
05:17 എന്ന് പറയുന്നത് "Hello World! 'a' is 10".
05:22 പ്രോഗ്രാം 'SampleClass' 'ഒബ്ജക്റ്റ് സൃഷ്ടിക്കാൻ ഇപ്പോൾ ലൈൻ നിർത്തി.
05:28 ഇപ്പോൾ SampleClass ന്റെ 'constructor പോകണം
05:32 ഇതിനായി, ടൂൾബാറിൽ നിന്ന് Step Into'ഓപ്ഷൻ തിരഞ്ഞെടുക്കാം.
05:41 Step Over തിരഞ്ഞെടുത്തു, 'constructor call ഉള്ളിലുള്ള മൂല്യത്തെ ഇപ്പോൾ 10 ആയി സജ്ജമാക്കിയതായി കാണാം.
05:51 നിങ്ങൾക്ക് വേരിയബിളിനു മുകളിൽ ഹോവർ ചെയ്ത് ഇത് പരിശോധിക്കാവുന്നതാണ്.
05:55 ഞാൻ Step Overആകുമ്പോൾ, 'this.variable' 10 ആണെന്ന് നമുക്ക് കാണാം
06:03 ഈ ഫംഗ്ഷനിൽ നിന്ന് പുറത്തുകടക്കാൻ എനിക്ക് Continue, Step Over അല്ലെങ്കിൽ Step Out.
06:11 രീതി പുറത്തുകടക്കാൻ Step-Out തിരഞ്ഞെടുക്കുക.
06:14 function call എവിടെയാണെന്ന് ഞാൻ ഇപ്പോൾ തിരിച്ചറിഞ്ഞു.
06:19 Step-Over വീണ്ടും പറയുമ്പോൾ aSample.value ഇപ്പോൾ 10 ആയി സജ്ജീകരിച്ചിരിക്കുന്നു.
06:27 ഇതാണ് ഞങ്ങൾ നോക്കുന്നത്
06:30 Breakpoints and Step Overs 'എന്നിവയ്ക്കുപുറമെ, പ്രോഗ്രാമിന്റെ എക്സിക്യൂഷനും കഴ്സറിനുള്ളിൽ നിർത്താം.
06:38 ഉദാഹരണത്തിന്, ഇവിടെ ഫങ്ഷനിലേക്ക് പോകുകയും d = b-5 എന്ന് പറയുന്ന വരിയിൽ കഴ്സറിനെ സജ്ജമാക്കുകയും ചെയ്യാം. .
06:49 ഇപ്പോൾ, ടൂൾബാറിൽ നിന്ന് Run To Cursor കഴ്സർ തിരഞ്ഞെടുക്കുക.
06:54 പ്രോഗ്രാമിന്റെ എക്സിക്യൂഷന് പ്രവര്ത്തനത്തില് പ്രവേശിക്കുകയും കഴ്സര് സ്ഥിതി ചെയ്യുന്ന വരിയില് അവസാനിക്കുകയും ചെയ്യുമെന്ന് നിങ്ങള് ശ്രദ്ധിക്കും.
07:05 b ന്റെ മൂല്യം 20 ആയി കണക്കാക്കി എന്ന് നിങ്ങൾക്കറിയാം.
07:10 Variableവിൻഡോയ്ക്കുള്ളിൽ അത് b20 ആയി നിശ്ചയിച്ചിരിക്കുന്നു.
07:14 ഇപ്പോൾ Step Over വീണ്ടും തെരഞ്ഞെടുക്കാം, ഒപ്പം ഡി സിയുടെ മൂല്യവും തുടങ്ങുകയും 15 ആയി മാറുകയും ചെയ്യും.
07:23 ഇപ്പോൾ, ഞാൻ ഒന്നുകിൽ തിരിച്ച് തിരിച്ച് അല്ലെങ്കിൽ പ്രോഗ്രാം എക്സിക്യൂഷൻ പൂർത്തിയാക്കാൻ കഴിയും.
07:29 Step Out തിരഞ്ഞെടുത്ത് function callതിരികെ വരട്ടെ.
07:36 GetC ()' 'ഫങ്ഷനിൽ നിങ്ങൾ ഹോവർ ചെയ്യുമ്പോൾ, ഫങ്ഷൻ 15 ന്റെ മൂല്യം തിരിച്ചറിഞ്ഞുവെന്ന് നിങ്ങൾ ശ്രദ്ധിക്കും.
07:43 വേരിയബിള് 'c' ഇതുവരെ ആ മൂല്യത്തെ അസൈന് ചെയ്തിട്ടില്ല.
07:47 അതിനാൽ, നമ്മൾ Step Over ചെയ്ത് ആ ലൈൻ നിർവ്വഹിക്കുമ്പോൾ, 'c' ന്റെ മൂല്യം 15 ആയി വരും.
07:55 നമുക്കിപ്പോൾ Variableവിൻഡോയിൽ ഇത് പരിശോധിക്കാം അല്ലെങ്കിൽ വേരിയബിളിൽ ഹോവർ ചെയ്യുക അതിന്റെ മൂല്യം പരിശോധിക്കാം.
08:03 ഇപ്പോൾ, ഡീബഗ്ഗിംഗ് സെഷൻ അവസാനിപ്പിക്കണമെങ്കിൽ, നിങ്ങൾക്ക് ടൂൾബാറിൽ നിന്നുംFinish Debugger Session ഓപ്ഷൻ തിരഞ്ഞെടുക്കാം
08:12 അടുത്ത ബ്രേക്ക്പോയിന്റിന് എക്സിക്യൂഷൻ തുടരാൻ നിങ്ങൾ ആഗ്രഹിക്കുന്നുവെങ്കിൽ, നിങ്ങൾക്ക് Continue ഓപ്ഷൻ തിരഞ്ഞെടുക്കാം.
08:19 നിങ്ങൾ പൂർത്തിയാക്കിയാൽ, ശേഷിക്കുന്ന പ്രോഗ്രാമിന്റെ എക്സിക്യൂഷൻ പൂർത്തിയാക്കാൻ 'Continue option തിരഞ്ഞെടുക്കാം.
08:25 ഇവിടെContinue തെരഞ്ഞെടുക്കുക
08:27 ഔട്ട്പുട്ട് വിൻഡോയിൽ, ഔട്ട്പുട്ട് എന്നെ കാണിക്കുന്നു:' b 20 , 'c' '15 ആണ്.
08:34 ഇപ്പോൾ, 'netbeans. ' എന്നതിലെ ഡീബഗ്ഗിങ്ങിന്റെ ഓപ്ഷനുകളുടെ ഒരു ദ്രുത അവലോകനം.
08:39 നിങ്ങൾക്ക് വിപുലമായ സവിശേഷത ക്രമീകരണങ്ങൾ വേണമെങ്കിൽ, നിങ്ങൾക്ക് കഴിയും
08:42 Toolsമെനുവിലേക്ക് പോവുകOptionsക്ലിക്കുചെയ്യുക. Miscellaneous ഓപ്ഷനിലേക്ക് പോയി Java Debugger ടാബിൽ ക്ലിക്കുചെയ്യുക.
08:53 മൾട്ടി-ത്രെഡ് പ്രോഗ്രാം ബ്രേക്ക്പോയിന്റ് ഓപ്ഷനുകൾക്കായി നിങ്ങൾക്ക് ഇവിടെ ക്രമീകരണങ്ങൾ മാറ്റാൻ കഴിയും
08:59 അല്ലെങ്കിൽ, ഏത് ഘട്ടങ്ങളാണ് തീരുമാനിക്കേണ്ടതെന്ന് തീരുമാനിക്കാനുള്ള filters ഉണ്ടായിരിക്കണം.
09:07 ഇപ്പോൾ, അസൈൻമെന്റിൽ
09:09 അസൈൻമെന്റായി, നിങ്ങളുടെ പ്രോഗ്രാമുകളിലേതെങ്കിലും എടുക്കുക, ഇതിനകം തന്നെ പിശകുകൾ ഉണ്ടെങ്കിൽ.
09:16 ഇല്ലെങ്കിൽ, 'logic' അല്ലെങ്കിൽ algorithm.ഉള്ള ചില പിശകുകൾ അവതരിപ്പിക്കുക
09:20 കോഡ് 'breakpoints സാധാരണയായി, നിങ്ങൾ error എന്ന സംശയാസ്പദമായ function കോൾഡിംഗ് പോയിന്റിൽ ഒരുbreak് ആക്കിയിരിക്കും.
09:29 ഫംഗ്ഷനിലേക്ക് പോകാൻ Step Intoഉപയോഗിക്കുക.
09:32 Step Overs execute ലൈനുകൾ ഉപയോഗിക്കുക, കൂടാതെ Variableവിൻഡോയിലെ വേരിയബിളിന്റെ മൂല്യങ്ങൾ പരിശോധിക്കുന്നത് ഉറപ്പാക്കുക.
09:41 error തിരിച്ചറിയാനും തിരുത്തുകയും സഹായിക്കുന്നതിന് ചില watch എസ് ചേർക്കുക.
09:45 രീതി ഔട്ട് ഘട്ടം.
09:48 നിങ്ങൾ അടുത്ത ബ്രേക്ക് പോയിൻറിൽ എത്തുന്നതുവരെ തുടരുക.
09:51 അവസാനമായി, debugger സെഷൻ, run നിങ്ങളുടെ അപ്ലിക്കേഷൻ പൂർത്തിയാക്കുക.
09:57 ഈ ടുട്ടോറിയലിൽ Netbeans Debugger. ഞങ്ങൾ പരിചയത്തിലായി.
10:02 breakpoints watches എങ്ങിനെ സജ്ജീകരിക്കാമെന്ന് ഞങ്ങൾ കണ്ടു.
10:06 കോഡ് പ്രവർത്തിക്കുമ്പോൾ ഞങ്ങൾ മൂല്യനിർണ്ണയം ചെയ്യാൻ ആഗ്രഹിക്കുന്ന അവതരണങ്ങൾ ചേർക്കുക
10:11 Step-Into, Step-Over, Step-Out, Run-to-Cursor ഓപ്ഷനുകളുപയോഗിച്ച് ഒരു പ്രോഗ്രാം നടപ്പിലാക്കുക.
10:19 കൂടാതെ,debugger വിപുലമായ ഡീബഗ്ഗിംഗിനായി എങ്ങനെ ക്രമീകരിക്കാമെന്ന് കണ്ടു
10:24 ഈ ട്യൂട്ടോറിയൽ നിങ്ങളുടെ ടെസ്റ്റിംഗ്, ഡീബഗ്ഗിംഗ് ടാസ്ക്കുകളിൽ നിങ്ങൾക്ക് ധാരാളം സമയം ലാഭിക്കുമെന്ന് പ്രതീക്ഷിക്കുന്നു.
10:30 സ്ക്രീനില് കാണിച്ചിരിക്കുന്ന link ല് ലഭ്യമായ വീഡിയോ കാണുക.
10:33 Spoken Tutorial project ന്റെ ചുരുക്ക രൂപമാണിത്‌
10:36 നിങ്ങള്‍ക്ക് നല്ല ബാന്‍വിഡ്ത്ത് ലഭ്യമല്ലെങ്കില്‍ വീഡിയോസ് ഡൗണ്‍ലോഡ് ചെയ്ത് കാണാം
10:41 Spoken Tutorial project team: ട്യൂട്ടോറിയല്‍സ് ഉപയോഗിച്ച് വര്‍ക്ക്‌ഷോപ്പുകള്‍ സംഘടിപ്പിക്കുന്നു .
10:46 ഓണ്‍ലൈന്‍ പരീക്ഷ പാസാകുന്നവര്‍ക്ക് സര്‍ട്ടിഫിക്കറ്റുകളും നല്‍കുന്നു
10:49 കൂടുതല്‍ വിവരങ്ങള്‍ക്ക് ഈ മെയില്‍ ബന്ധപ്പെടുക  :contact@spoken-tutorial.org
10:55 Spoken Tutorial പ്രോജക്ട് Talk to a Teacher പ്രോജക്ട്ന്റെ ഭാഗമാണ്‌
10:59 നാഷണല്‍ മിഷണ്‍ ഓണ്‍ എഡ്യുക്കേഷന്റെ സഹായത്തോടെ ICT, MHRD, Government of India യാണ്‌ ഈ ട്യൂട്ടോറിയല്‍ തയ്യാറാക്കിയത്
11:05 കൂടുതല്‍ വിവരങ്ങള്‍ താഴെയുളള ലിങ്കില്‍ ലഭിക്കും :spoken-tutorial.org/NMEICT-Intro.
11:14 sarin babu ആണ്‌ ഈ ട്യൂട്ടോറിയല്‍ സംഭാവന ചെയ്തിരിക്കുന്നത്‌
11:18 ഞങ്ങളുടെ Netbeans ട്യൂട്ടോറിയലില്‍ അംഗമായതിനും ഉപയോഗിച്ചതിനും നന്ദി

Contributors and Content Editors

PoojaMoolya, Vijinair