Netbeans/C2/Netbeans-Debugger/Malayalam
From Script | Spoken-Tutorial
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 ട്യൂട്ടോറിയലില് അംഗമായതിനും ഉപയോഗിച്ചതിനും നന്ദി |