Netbeans/C2/Netbeans-Debugger/Oriya
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 | debugger ନିଜକୁ ନିଜେ configure କରିବା ପାଇଁ ଅପଶନଗୁଡିକୁ ପ୍ରଦର୍ଶନ କରିବା |
01:12 | ବର୍ତ୍ତମାନ, ଏହି ନମୂନା କୋଡକୁ debug କରିବା ସହ ଚାଲନ୍ତୁ ଆରମ୍ଭ କରିବା |
01:17 | Netbeans IDEକୁ ଫେରିଆସନ୍ତୁ |
01:20 | ଏହାର ପ୍ରଦର୍ଶନ ପାଇଁ, ମୋ IDEରେ sampleDebug ନାମକ ଗୋଟିଏ ଜାଭା ଆପ୍ଲିକେଶନକୁ ସୃଷ୍ଟି କରିସାରିଛି |
01:27 | ଏହା ଗୋଟିଏ ଛୋଟ ପ୍ରୋଗ୍ରାମ୍ ଅଟେ ଯାହା a, b ଓ c ନାମକ ତିନୋଟି ଇଣ୍ଟିଜର୍ ଭେଲ୍ୟୁକୁ ଇନିଶିଆଲାଇଜ୍ କରୁଛି |
01:35 | ତା’ପରେ ଏହା Hello World!କୁ ଏବଂ aର ଭେଲ୍ୟୂକୁ ପ୍ରିଣ୍ଟ କରିବ |
01:40 | ଏହା SampleClass ନାମକ ଗୋଟିଏ class ଅବଜେକ୍ଟକୁ ସୃଷ୍ଟି କରିବ ଯାହାର ଗୋଟିଏ privateଇଣ୍ଟିଜର୍ ଭେଲ୍ୟୁ ଭାବେ ଏକ value ଇଣ୍ଟିଜର୍ ଅଛି |
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 | ଯେତେବେଳେ ଟୂଲବାରରେ ଥିବା Debug Project ବଟନ୍ ଉପରେ କ୍ଲିକ୍ କରି, |
02:31 | debugging ମୋଡରେ ପ୍ରୋଗ୍ରାମକୁ run କରିବେ, |
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 | ଏଠାରେ ଗୋଟିଏ 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 | ଏଠାରେ ଥିବା Evaluate Expression ବଟନ୍ ଉପରେ କ୍ଲିକ୍ କରନ୍ତୁ ଏବଂ Variable ୱିଣ୍ଡୋରେ ଏହା (a-4)ର ଭେଲ୍ୟୂ 6 ଅଟେ ବୋଲି କହିବ |
04:56 | ବର୍ତ୍ତମାନ ଆଗକୁ ବଢିବା ସହ କୋଡର ଏହି ସିଙ୍ଗଲ୍ ଲାଇନକୁ ନିଷ୍ପାଦନ କରନ୍ତୁ |
05:00 | ତାହା କରିବା ପାଇଁ, ଟୂଲବାରରୁ Step-Over ବଟନକୁ ଚୟନ କରନ୍ତୁ |
05:06 | ତାହା Hello Worldକୁ ପ୍ରିଣ୍ଟ କରିବା ପାଇଁ, କେବଳ ସେହି କୋଡର 1 single lineକୁ ନିଷ୍ପାଦନ କରିବ |
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 | Breakpoint ଓ Step Overଗୁଡିକ ବ୍ୟତିତ, କର୍ସର୍ ଥିବା ଲାଇନ୍ ଉପରେ ପ୍ରୋଗ୍ରାମର ନିଷ୍ପାଦନକୁ ମଧ୍ୟ ବନ୍ଦ କରିପାରିବେ |
06:38 | ଉଦାହରଣସ୍ଵରୂପ, ଏଠାରେ ପ୍ରୋଗ୍ରାମ୍ ମଧ୍ୟକୁ ଯା’ନ୍ତୁ ଏବଂ d=b-5 ବୋଲାଉଥିବା ଲାଇନ୍ ଉପରେ କର୍ସରକୁ ରଖନ୍ତୁ |
06:49 | ବର୍ତ୍ତମାନ, ଟୂଲବାରରେ ଥିବା Run To Cursor ଅପଶନକୁ ଚୟନ କରନ୍ତୁ |
06:54 | ଲକ୍ଷ୍ୟ କରନ୍ତୁ ଯେ ପ୍ରୋଗ୍ରାମ୍, ନିଷ୍ପାଦନ ହୋଇ ଫଙ୍କଶନ୍ ମଧ୍ୟକୁ ଚାଲିଯିବ ଏବଂ କର୍ସର୍ ଥିବା ଲାଇନ୍ ଉପରେ ବନ୍ଦ ହୋଇଯିବ |
07:05 | ଆପଣ ଦେଖିପାରିବେ ଯେ ଏହା bର ଭେଲ୍ୟୁକୁ 20 ଭାବେ କମ୍ପ୍ୟୁଟ୍ କରିଛି |
07:10 | ଏବଂ Variable ୱିଣ୍ଡୋ ମଧ୍ୟରେ ଏହା bକୁ 20ରେ ସେଟ୍ କରିଛି |
07:14 | ବର୍ତ୍ତମାନ, ପୁନର୍ବାର Step Overକୁ ଚୟନ କରନ୍ତୁ ଏବଂ dର ଭେଲ୍ୟୁ ମଧ୍ୟ ଇନିଶିଆଲାଇଜ୍ ହେବା ସହିତ 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 ଅପଶନକୁ ଚୟନ କରିପାରିବେ |
08:25 | ଏଠାରେ Continue ଚୟନ କରନ୍ତୁ |
08:27 | Output ୱିଣ୍ଡୋରେ, ଏହା ଆଉଟପୁଟ୍ ପ୍ରଦର୍ଶନ କରିବ ଯେ: b is 20 and c is 15 |
08:34 | ବର୍ତ୍ତମାନ, ଏହା netbeansର ଡିବଗିଙ୍ଗ ଅପଶନଗୁଡିକର ଗୋଟିଏ ବିହଙ୍ଗାବଲୋକନ ଥିଲା |
08:39 | ଯଦି ଆପଣ କୌଣସି ଆଧୁନିକ ଫିଚର୍ ସେଟିଙ୍ଗ ଆବଶ୍ୟକ କରନ୍ତି ତେବେ ଦେଖିପାରିବେ |
08:42 | Tools ମେନୁକୁ ଯା’ନ୍ତୁ ଏବଂ Options ଉପରେ କ୍ଲିକ୍ କରନ୍ତୁ. Miscellaneous ଅପଶନକୁ ଯିବା ସହିତ Java Debugger ଟାବ୍ ଉପରେ କ୍ଲିକ୍ କରନ୍ତୁ |
08:53 | ଏଠାରେ, multi-threaded ପ୍ରୋଗ୍ରାମ୍ ବ୍ରେକପଏଣ୍ଟ ଅପଶନଗୁଡିକ ପାଇଁ ସେଟିଙ୍ଗଗୁଡିକୁ ପରିବର୍ତ୍ତନ କରିପାରିବେ |
08:59 | କିମ୍ବା ଚାହୁଁଥିବା ମେଥଡକୁ ଯିବା ପାଇଁ, filtersକୁ ବ୍ୟବହାର କରିପାରିବେ |
09:07 | ବର୍ତ୍ତମାନ, ଆସାଇନମେଣ୍ଟ |
09:09 | ଗୋଟିଏ ଆସାଇନମେଣ୍ଟ ଭାବେ, ଯେକୌଣସି ପ୍ରୋଗ୍ରାମକୁ ନିଅନ୍ତୁ, ଯଦି ପ୍ରୋଗ୍ରାମରେ ଏରର୍ ଥାଏ ତେବେ ଚମତ୍କାର ହେବ |
09:16 | ଯଦି ନାହିଁ, logic କିମ୍ବା algorithm ସହିତ କିଛି ଏରରକୁ ପ୍ରବେଶ କରନ୍ତୁ |
09:20 | କୋଡରେ breakpointଗୁଡିକୁ ସେଟ୍ କରନ୍ତୁ. ସାଧାରଣତଃ ଗୋଟିଏ functionକୁ କଲ୍ କରିବା ସ୍ଥାନରେ ଏକ breakକୁ ସେଟ୍ କରନ୍ତୁ ଯେଉଁଠି error ଥିବା ଆପଣ ସଂଦେହ କରୁଛନ୍ତି |
09:29 | Step Intoକୁ ବ୍ୟବହାର କରି ଫଙ୍କଶନ୍ ମଧ୍ୟକୁ ଯା’ନ୍ତୁ |
09:32 | ଲାଇନଗୁଡିକୁ execute କରିବା ପାଇଁ Step Overକୁ ବ୍ୟବହାର କରନ୍ତୁ ଏବଂ Variable ୱିଣ୍ଡୋରେ ଭେଲ୍ୟୂଗୁଡିକୁ ଯାଞ୍ଚ କରିବାକୁ ସୁନିଶ୍ଚିତ କରନ୍ତୁ |
09:41 | errorକୁ ଚିହ୍ନଟ ଓ ସଂଶୋଧନ କରିବାରେ ସାହାଯ୍ୟ ପାଇଁ, କିଛି watchକୁ ସଂଯୁକ୍ତ କରନ୍ତୁ |
09:45 | ମେଥଡରୁ Step Out କରନ୍ତୁ |
09:48 | ପରବର୍ତ୍ତୀ ବ୍ରେକପଏଣ୍ଟରେ ପହଞ୍ଚିବା ପର୍ଯ୍ୟନ୍ତ Continue କରନ୍ତୁ |
09:51 | ଏବଂ ଶେଷରେ debugger ସେସନକୁ ସମାପ୍ତ କରନ୍ତୁ ଏବଂ ଆପ୍ଲିକେଶନକୁ run କରନ୍ତୁ |
09:57 | ଏହି ଟ୍ୟୁଟୋରିଆଲରେ ଆମେ Netbeans Debugger ସହିତ ସୁପରିଚିତ ହେଲେ |
10:02 | କିପରି breakpoint ଓ watchଗୁଡିକୁ ସେଟ୍ କରାଯାଏ ଆମେ ଦେଖିଲେ |
10:06 | କୋଡ୍ ରନ୍ ହେଉଥିବା ସମୟରେ, ମୂଲ୍ୟାଙ୍କିତ କରିବାକୁ ଚାହୁଁଥିବା ଏକ୍ସପ୍ରେସନଗୁଡିକୁ ସଂଯୁକ୍ତ କରନ୍ତୁ |
10:11 | Step-Into, Step-Over, Step-Out ଓ Run-to-Cursor ଅପଶନଗୁଡିକ ସହିତ ଗୋଟିଏ ପ୍ରୋଗ୍ରାମର ନିଷ୍ପାଦନକୁ ଟ୍ରେସ୍ କରନ୍ତୁ |
10:19 | ଆଧୁନିକ ଡିବଗିଙ୍ଗ ପାଇଁ କିପରି debugger କନଫିଗର୍ କରାଯାଏ, ତାହା ମଧ୍ୟ ଦେଖିଲେ |
10:24 | ଆଶାକରୁଛୁ, ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ ଆପଣଙ୍କର ଟେଷ୍ଟିଙ୍ଗ ଓ ଡିବଗିଙ୍ଗର ଟାସ୍କର ପାଇଁ ଥିବା ଅନେକ ସମୟକୁ ସେଭ୍ କରିଥିବ |
10:30 | ସ୍କ୍ରୀନ୍ ଉପରେ ପ୍ରଦର୍ଶିତ ଲିଙ୍କରେ ଉପଲବ୍ଧ ଥିବା ଭିଡିଓକୁ ଦେଖନ୍ତୁ |
10:33 | ଏହା ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ପ୍ରୋଜେକ୍ଟକୁ ସାରାଂଶିତ କରେ |
10:36 | ଯଦି ଆପଣଙ୍କର ଭଲ ବ୍ୟାଣ୍ଡୱିଡଥ୍ ନାହିଁ, ଏହାକୁ ଡାଉନଲୋଡ୍ କରିଦେଖିପାରିବେ |
10:41 | ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ ପ୍ରୋଜେକ୍ଟ ଟିମ୍, ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ୍ସ ବ୍ୟବହାର କରି କର୍ମଶାଳାମାନ ଚଲାନ୍ତି |
10:46 | ଅନଲାଇନ୍ ଟେଷ୍ଟ ପାସ୍ କରୁଥିବା ବ୍ୟକ୍ତିମାନଙ୍କୁ ପ୍ରମାଣପତ୍ର ଦିଅନ୍ତି. |
10:49 | ଅଧିକ ବିବରଣୀ ପାଇଁ ଦୟାକରି contact@spoken-tutorial.orgକୁ ଲେଖନ୍ତୁ |
10:55 | ସ୍ପୋକନ୍ ଟ୍ୟୁଟୋରିଆଲ ପ୍ରୋଜେକ୍ଟ, ଟକ୍ ଟୁ ଏ ଟିଚର୍ ପ୍ରୋଜେକ୍ଟର ଏକ ଅଂଶ |
10:59 | ଏହା ଭାରତ ସରକାରଙ୍କ MHRDର ICT ମାଧ୍ୟମରେ ରାଷ୍ଟ୍ରୀୟ ସାକ୍ଷରତା ମିଶନ୍ ଦ୍ୱାରା ସମର୍ଥିତ |
11:05 | ଏହି ମିଶନ୍ ଉପରେ ଅଧିକ ବିବରଣୀ: spoken-tutorial.org /NMEICT-Introରେ ଉପଲବ୍ଧ |
11:14 | ଏହି ଟ୍ୟୁଟୋରିଆଲ୍ IT for Change ଦ୍ଵାରା ସମର୍ଥିତ |
11:18 | ଆଇଆଇଟି ବମ୍ୱେ ତରଫରୁ, ପ୍ରଦୀପ ମହାପାତ୍ରଙ୍କ ସହ ମୁଁ ପ୍ରଭାସ ତ୍ରିପାଠୀ ଆପଣଙ୍କଠାରୁ ବିଦାୟ ନେଉଛି. ଆମ ସହିତ ଜଡ଼ିତ ହୋଇଥିବାରୁ ଧନ୍ୟବାଦ |