Netbeans/C2/Netbeans-Debugger/Punjabi

Time	Narration
00:01	ਸਤਿ ਸ਼੍ਰੀ ਅਕਾਲ ਦੋਸਤੋ ।
00:02	Netbeans Debugger ਦੇ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਤੁਹਾਡਾ ਸਾਰਿਆ ਦਾ ਸਵਾਗਤ ਹੈ ।
00:06	ਜੇ ਤੁਸੀਂ Netbeans ਦੀ ਵਰਤੋਂ ਪਹਿਲੀ ਵਾਰ ਕਰ ਰਹੇ ਹੋ, ਤਾਂ ਕ੍ਰਿਪਾ ਕਰਕੇ Spoken Tutorial ਵੈੱਬਸਾਈਟ ‘ਤੇ ਪਿਛਲੇ ਟਿਊਟੋਰਿਅਲ ਨੂੰ ਵੇਖੋ ।
00:14	ਇਸ ਦੇ ਲਈ, ਮੈਂ ਵਰਤੋਂ ਕਰ ਰਿਹਾ ਹਾਂ ਲਿਨਕਸ ਓਪਰੇਟਿੰਗ ਸਿਸਟਮ ਊਬੰਟੂ v12.04,
00:21	ਅਤੇ Netbeans IDE v7.1.1
00:26	ਅਸੀਂ ਸਾਰੇ ਜਾਣਦੇ ਹਾਂ, ਪ੍ਰੋਗਰਾਮਸ debugg ਕਰਨਾ ਮਿਹਨਤ ਵਾਲਾ ਕੰਮ ਹੋ ਸਕਦਾ ਹੈ ।
00:31	ਇਸ ਲਈ, debugging ਟੂਲ ਦੇ ਬਾਰੇ ਵਿੱਚ ਜਾਣਨਾ ਅਤੇ ਇਸਦੇ ਫੀਚਰਸ ਦੇ ਨਾਲ ਜਾਣੂ ਹੋਣਾ, ਤੁਹਾਡੇ ਮਹੱਤਵਪੂਰਣ ਸਮੇਂ ਦੀ ਬਚਤ ਵਿੱਚ ਮਦਦ ਕਰ ਸਕਦਾ ਹੈ ।
00:39	ਇਹ ਸ਼ਕਤੀਸ਼ਾਲੀ debugging ਟੂਲ ਬਹੁਤ ਹੀ ਲਾਭਦਾਇਕ ਹੈ ।
00:42	ਖਾਸ ਤੌਰ 'ਤੇ ਉਸ ਸਮੇਂ, ਜਦੋਂ ਤੁਹਾਨੂੰ ਵੱਡੇ ਪ੍ਰੋਗਰਾਮਸ ਕੋਡ ਜਾਂ ਟੈਸਟ ਕਰਨੇ ਹੋਣ ।
00:46	ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ Netbeans Debugger ਦੁਆਰਾ ਪ੍ਰਦਾਨ ਕੁੱਝ ਫੀਚਰਸ ਦੇ ਬਾਰੇ ਵਿੱਚ ਸਿੱਖਾਂਗੇ ।
00:53	ਇਹ ਟਿਊਟੋਰਿਅਲ ਤੁਹਾਨੂੰ
00:55	debugging ਵਿੰਡੋ
00:58	breakpoints ਕਾਂਫਿਗਰ ਕਰਨਾ,
01:00	expressions ਦਾ ਮੁਲਾਂਕਣ ਜਾਂ watches ਸੈੱਟ ਕਰਨਾ,
01:04	ਆਪਣੇ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਪਤਾ ਲਗਾਉਣ ਦੇ ਲਈ ਚੋਣ ਜਾਂ ਵਿਕਲਪ,
01:17	ਅਤੇ debugger ਕਾਂਫਿਗਰ ਕਰਨ ਦੇ ਲਈ ਚੋਣ ਜਾਂ ਵਿਕਲਪ ਦੇ ਬਾਰੇ ਵਿੱਚ ਜਾਣੂ ਕਰਵਾਏਗਾ ।
01:12	ਹੁਣ ਇਸ ਸਿੰਪਲ ਕੋਡ ਨੂੰ ਸ਼ੁਰੂ ਅਤੇ debug ਕਰਦੇ ਹਾਂ ।
01:17	ਮੈਂ Netbeans IDE ‘ਤੇ ਜਾਵਾਂਗਾ ।
01:20	ਮੈਂ ਇਸ ਦੇ ਲਈ, ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਆਪਣੇ IDE ਵਿੱਚ ਜਾਵਾ ਐਪਲੀਕੇਸ਼ਨ sample Debug ਬਣਾ ਦਿੱਤੀ ਹੈ ।
01:27	ਇਹ ਇੱਕ ਛੋਟਾ ਪ੍ਰੋਗਰਾਮ ਹੈ, ਜੋ ਤਿੰਨ ਇੰਟਿਜਰ ਵੈਲਿਊ a,b, ਅਤੇ c ਨੂੰ ਇਨੀਸ਼ਿਲਾਇਜ ਕਰਦਾ ਹੈ ।
01:35	ਫਿਰ Hello World ! ਅਤੇ a ਦੀ ਵੈਲਿਊ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ ।
01:40	ਇਹ ਇੱਕ ਕਲਾਸ ਆਬਜੈਕਟ SampleClass, ਵੀ ਬਣਾਉਂਦਾ ਹੈ, ਜਿਸ ਵਿੱਚ ਪ੍ਰਾਇਵੇਟ ਇੰਟਿਜਰ ਵੈਲਿਊ ਦੇ ਰੂਪ ਵਿੱਚ value ਇੰਟਿਜਰ ਹੈ ।
01:52	ਫਿਰ, ਇਹ b ਦੀ ਵੈਲਿਊ ਦੀ ਗਿਣਤੀ ਕਰਦਾ ਹੈ ।
01:55	ਅਤੇ c ਦੀ ਵੈਲਿਊ ਦੀ ਗਿਣਤੀ ਕਰਨ ਦੇ ਲਈ ਫੰਕਸ਼ਨ ਕਾਲ ਕਰਦਾ ਹੈ ।
02:00	ਅਤੇ b ਅਤੇ c ਦੀ ਵੈਲਿਊ ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦਾ ਹੈ ।
02:05	debugging ਦੇ ਨਾਲ ਸ਼ੁਰੂ ਕਰਨ ਦੇ ਲਈ, ਪਹਿਲਾਂ ਬਰੇਕ ਪੁਆਇੰਟ ਨੂੰ ਸੈੱਟ ਕਰਦੇ ਹਾਂ ।
02:09	ਬਰੇਕ ਪੁਆਇੰਟ ਨੂੰ ਸੈੱਟ ਕਰਨ ਦੇ ਲਈ, ਲਾਈਨ ਨੰਬਰ ‘ਤੇ ਕਲਿਕ ਕਰੋ ।
02:13	ਮੈਂ ਇਸ ਲਾਈਨ ਨੂੰ ਸੈੱਟ ਕਰਾਂਗਾ ਜੋ Hello World ! ਨੂੰ ਪ੍ਰਿੰਟ ਕਰਦੀ ਹੈ ।
02:18	ਨੋਟ ਕਰੋ ਕਿ, ਲਾਈਨ ਜਿਸ ਵਿੱਚ ਬਰੇਕ ਪੁਆਇੰਟ ਸੈੱਟ ਹੈ ਇਸਦਾ ਰੰਗ ਪਿੰਕ ਹੋ ਜਾਂਦਾ ਹੈ, ਅਤੇ ਇਸਦੇ ਲਾਈਨ ਨੰਬਰ ਦੇ ਸਾਹਮਣੇ ਇੱਕ ਛੋਟੇ ਸਕਵੇਰ ਦੁਆਰਾ ਨਿਸ਼ਾਨ ਲਗਾਇਆ ਜਾਂਦਾ ਹੈ ।
02:28	ਜਦੋਂ ਤੁਸੀਂ ਟੂਲਬਾਰ ਵਿੱਚ Debug Project ਬਟਨ ‘ਤੇ ਕਲਿਕ ਕਰਕੇ
02:31	debugging ਮੋਡ ਵਿੱਚ ਪ੍ਰੋਗਰਾਮ ਨੂੰ ਰਨ ਕਰਦੇ ਹੋ
02:35	ਤਾਂ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਉਸ ਲਾਈਨ ‘ਤੇ ਰੁਕ ਜਾਂਦੀ ਹੈ, ਜਿੱਥੇ ਬਰੇਕ ਪੁਆਇੰਟ ਸਥਿਤ ਹੈ ।
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	ਉਦਾਹਰਣ ਦੇ ਲਈ, ਮੈਂ ਇੰਟਿਜਰ ਵੈਲਿਊ a Sample ‘ਤੇ watch ਚਾਹੁੰਦਾ ਹਾਂ ।
03:48	workspace ਦੇ ਹੇਠਾਂ Variables ਵਿੰਡੋ ਵਿੱਚ,ਮੈਂ Enter new Watch ਓਪਸ਼ਨ ‘ਤੇ ਡਬਲ ਕਲਿਕ ਕਰਾਂਗਾ ਅਤੇ ਵੈਰੀਏਬਲ a Sample.value ਦਾ ਨਾਮ ਦਰਜ ਕਰਾਂਗਾ ।
04:02	OK.’ਤੇ ਕਲਿਕ ਕਰੋ ।
04:06	ਹੁਣ ਤੱਕ a Sample ਨਹੀਂ ਬਣਿਆ ਹੈ, ਇਸ ਲਈ: ਇਹ ਕਹਿੰਦਾ ਹੈ ਕਿ ਇਸਨੂੰ ਵੈਲਿਊ ਪਤਾ ਨਹੀਂ ਹੈ ।
04:12	ਇੱਕ ਵਾਰ ਇਹ ਲਾਈਨ ਚਲਾਉਂਦਾ ਹੈ, ਅਸੀਂ ਪਤਾ ਕਰਾਂਗੇ ਕਿ ਵੈਰੀਏਬਲ ਵਿੱਚ ਕੀ ਸ਼ਾਮਿਲ ਹੈ ।
04:16	ਇਸ ਤਰ੍ਹਾਂ, ਤੁਸੀਂ watch ਕਰ ਸਕਦੇ ਹੋ ਅਤੇ expressions ਦਾ ਮੁਲਾਂਕਣ ਕਰ ਸਕਦੇ ਹੋ ।
04:21	ਇੱਥੇ ਮੈਂ b = a + 10 ਲਈ ਚੈੱਕ ਕਰ ਰਿਹਾ ਹਾਂ ।
04:25	ਕੀ ਹੋਵੇਗਾ, ਜੇ ਮੈਂ ਜਾਣਨਾ ਚਾਹੁੰਦਾ ਹਾਂ ਕਿ a - 4 ਕੀ ਹੈ ।
04:29	ਇਸ ਲਈ: ਮੈਂ ਮੈਨਿਊ ਬਾਰ ਵਿੱਚ Debug ‘ਤੇ ਜਾਂਦਾ ਹਾਂ, ਅਤੇ Evaluate expression ਵਿਕਲਪ ਜਾਂ ਓਪਸ਼ਨ ਚੁਣਦਾ ਹਾਂ ।
04:37	workspace ਵਿੱਚ Evaluate Code ਵਿੰਡੋ ਵਿਖਾਈ ਦਿੰਦੀ ਹੈ ।
04:41	ਇੱਥੇ ਮੈਂ expression a - 4.ਦਰਜ ਕਰਾਂਗਾ ।
04:45	ਇੱਥੇ Evaluate Expression ਬਟਨ ‘ਤੇ ਕਲਿਕ ਕਰੋ, ਅਤੇ Variable ਵਿੰਡੋ ਵਿੱਚ ਇਹ ਦਰਸਾਉਂਦਾ ਹੈ 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.ਦੇ ਕੰਸਟਰਕਟਰ ਵਿੱਚ ਜਾਣਾ ਚਾਹੁੰਦਾ ਹਾਂ ।
05:32	ਇਸ ਦੇ ਲਈ, ਮੈਂ ਟੂਲਬਾਰ [me] Step Into ਵਿਕਲਪ ਜਾਂ ਓਪਸ਼ਨ ਨੂੰ ਚੁਣ ਸਕਦਾ ਹਾਂ ।
05:41	ਫਿਰ ਮੈਂ Step Over ਚੁਣ ਸਕਦਾ ਹਾਂ ਅਤੇ ਵੇਖਦਾ ਹਾਂ ਕਿ ਕੰਸਟਰਕਟਰ call ਵਿੱਚ ਆਈ ਹੋਈ ਵੈਲਿਊ ਹੁਣ 10 ਸੈੱਟ ਹੋ ਗਈ ਹੈ ।
05:51	ਤੁਸੀਂ ਉਸਨੂੰ ਵੈਰੀਏਬਲ ‘ਤੇ ਲੈ ਜਾ ਕੇ ਵੀ ਚੈੱਕ ਕਰ ਸਕਦੇ ਹੋ ।
05:55	ਜਦੋਂ ਮੈਂ ਅਗਲੇ ਸਟੈਪ ‘ਤੇ ਜਾਂਦਾ ਹਾਂ, ਅਸੀਂ ਵੇਖ ਸਕਦੇ ਹਾਂ ਕਿ this.variable 10 ਸੈੱਟ ਹੋ ਗਿਆ ਹੈ ।
06:03	ਇਸ ਫੰਕਸ਼ਨ ਤੋਂ ਬਾਹਰ ਨਿਕਲਣ ਦੇ ਲਈ, ਮੈਂ ਜਾਂ ਤਾਂ Continue,Step Over ਜਾਂ Step Out.ਚੁਣ ਸਕਦਾ ਹਾਂ ।
06:11	ਮੈਥਡ ਤੋਂ ਬਾਹਰ ਜਾਣ ਦੇ ਲਈ ਮੈਂ Step - Out ਚੁਣਦਾ ਹਾਂ ।
06:14	ਅਤੇ ਹੁਣ ਮੈਂ ਉੱਥੇ ਹਾਂ ਜਿੱਥੇ ਫੰਕਸ਼ਨ call ਬਣਾਇਆ ਸੀ ।
06:19	ਜਦੋਂ ਮੈਂ ਫਿਰ ਤੋਂ Step - Over ਕਹਿੰਦਾ ਹਾਂ, ਤੁਸੀਂ ਵੇਖੋਗੇ ਕਿ aSample.value ਹੁਣ 10 ਵਿੱਚ ਸੈੱਟ ਹੋ ਗਈ ਹੈ ।
06:27	ਇਹ ਉਹ ਹੈ ਜਿਸ ਨੂੰ ਅਸੀਂ ਵੇਖਣਾ ਚਾਹੁੰਦੇ ਸੀ ।
06:30	Breakpoints ਅਤੇ Step Overs ਦੇ ਇਲਾਵਾ, ਤੁਸੀਂ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਕਰਸਰ ਦੀ ਲਾਈਨ ‘ਤੇ ਵੀ ਰੋਕ ਸਕਦੇ ਹੋ ।
06:38	ਉਦਾਹਰਣ ਦੇ ਲਈ, ਇੱਥੇ ਫੰਕਸ਼ਨ ਵਿੱਚ ਜਾਓ ਅਤੇ ਇਸ ਲਾਈਨ ‘ਤੇ ਕਰਸਰ ਸੈੱਟ ਕਰਨਾ ਹੈ, ਜੋ ਕਹਿੰਦਾ ਹੈ d = b - 5 ;.
06:49	ਹੁਣ ਟੂਲਬਾਰ ਵਿੱਚ Run To Cursor ਵਿਕਲਪ ਜਾਂ ਓਪਸ਼ਨ ਚੁਣੋ ।
06:54	ਤੁਸੀਂ ਵੇਖੋਗੇ ਕਿ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਫੰਕਸ਼ਨ ਵਿੱਚ ਹੋ ਜਾਂਦੀ ਹੈ ਅਤੇ ਲਾਈਨ ‘ਤੇ ਰੁੱਕ ਜਾਂਦੀ ਹੈ ਜਿੱਥੇ ਕਰਸਰ ਸਥਿਤ ਹੈ ।
07:05	ਤੁਸੀਂ ਵੇਖ ਸਕਦੇ ਹੋ ਕਿ, ਇਸਨੇ 20 ਦੇ ਰੂਪ ਵਿੱਚ b ਦੀ ਵੈਲਿਊ ਦੀ ਗਿਣਤੀ ਕੀਤੀ ਹੈ ।
07:10	ਅਤੇ variable ਵਿੰਡੋ ਦੇ ਅੰਦਰ, b ਦੇ ਲਈ 20 ਸੈੱਟ ਕੀਤਾ ਹੈ ।
07:14	ਹੁਣ, ਮੈਂ ਫਿਰ ਤੋਂ Step Over ਚੁਣ ਸਕਦਾ ਹਾਂ ਅਤੇ d ਦੀ ਵੈਲਿਊ ਵੀ ਇਨੀਸ਼ਿਲਾਇਜ ਹੁੰਦੀ ਹੈ ਅਤੇ 15 ਹੋ ਜਾਂਦੀ ਹੈ ।
07:23	ਹੁਣ, ਮੈਂ ਜਾਂ ਤਾਂ ਰਿਟਰਨ ਚੁਣ ਸਕਦਾ ਹਾਂ ਜਾਂ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਪੂਰਾ ਕਰ ਸਕਦਾ ਹਾਂ ।
07:29	ਮੈਂ Step Out ਚੁਣਦਾ ਹਾਂ ਅਤੇ ਫੰਕਸ਼ਨ ਕਾਲ ‘ਤੇ ਵਾਪਸ ਆਉਂਦੇ ਹਾਂ ।
07:36	ਜਦੋਂ ਤੁਸੀਂ getC () ਫੰਕਸ਼ਨ ‘ਤੇ ਜਾਵੋਗੇ, ਤੁਸੀਂ ਧਿਆਨ ਦਿਓ ਕਿ ਫੰਕਸ਼ਨ ਨੇ 15 ਵੈਲਿਊ ਰਿਟਰਨ ਕੀਤੀ ਹੈ ।
07:43	ਵੈਰੀਏਬਲ c ਨੂੰ ਹੁਣ ਤੱਕ ਉਹ ਵੈਲਿਊ ਨਿਯੁਕਤ ਨਹੀਂ ਕੀਤੀ ਗਈ ਹੈ ।
07:47	ਇਸ ਲਈ: ਜਦੋਂ ਅਸੀਂ Step Over ਕਰਦੇ ਹਾਂ ਅਤੇ ਉਸ ਲਾਈਨ ਨੂੰ ਚਲਾਉਂਦੇ ਹਾਂ, c 15 ਵੈਲਿਊ ਪ੍ਰਾਪਤ ਕਰੇਗੀ ।
07:55	ਅਸੀਂ ਹੁਣ ਇਸ ਨੂੰ ਵੈਰੀਏਬਲ ਵਿੰਡੋ ਵਿੱਚ ਚੈੱਕ ਕਰ ਸਕਦੇ ਹਾਂ ਜਾਂ ਇਸ ਦੀ ਵੈਲਿਊ ਨੂੰ ਚੈੱਕ ਕਰਨ ਦੇ ਲਈ variable ‘ਤੇ ਜਾਓ ।
08:03	ਹੁਣ ਜੇ ਤੁਸੀਂ debugging ਸੈਸ਼ਨ ਰੋਕਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ ਟੂਲਬਾਰ ਤੋਂ Finish Debugger Session ਵਿਕਲਪ ਜਾਂ ਓਪਸ਼ਨ ਚੁਣ ਸਕਦੇ ਹੋ ।
08:12	ਜੇ ਤੁਸੀਂ ਅਗਲੇ breakpoint ਦੇ ਲਈ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਜਾਰੀ ਰੱਖਣਾ ਚਾਹੁੰਦੇ ਹੋ, ਤੁਸੀਂ Continue ਵਿਕਲਪ ਚੁਣ ਸਕਦੇ ਹੋ ।
08:19	ਇੱਕ ਵਾਰ ਪੂਰਾ ਕਰ ਲਵੋਂ, ਤੁਸੀਂ ਬਾਕੀ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਨੂੰ ਪੂਰਾ ਕਰਨ ਦੇ ਲਈ Continue option ਵੀ ਚੁਣ ਸਕਦੇ ਹੋ ।
08:25	ਮੈਂ ਇੱਥੇ Continue ਚੁਣਦਾ ਹਾਂ ।
08:27	ਆਉਟਪੁਟ ਵਿੰਡੋ ਵਿੱਚ, ਇਹ ਮੈਨੂੰ b is 20 ਅਤੇ c is 15 ਆਉਟਪੁਟ ਦਿਖਾਉਂਦਾ ਹੈ ।
08:34	ਇਹ netbeans ‘ਤੇ debugging ਦੇ ਵਿਕਲਪਾਂ ਦਾ ਇੱਕ ਨਿਰੀਖਣ ਸੀ ।
08:39	ਜੇ ਤੁਸੀਂ ਕੋਈ ਐਡਵਾਂਸ ਫੀਚਰਸ ਸੇਟਿੰਗ ਚਾਹੁੰਦੇ ਹੋ, ਤਾਂ ਤੁਸੀਂ
08:42	Tools ਮੈਨਿਊ ‘ਤੇ ਜਾ ਸਕਦੇ ਹੋ, Options ‘ਤੇ ਕਲਿਕ ਕਰੋ, Miscellaneous ਵਿਕਲਪ ‘ਤੇ ਜਾਓ Java Debugger ਟੈਬ ‘ਤੇ ਕਲਿਕ ਕਰੋ ।
08:53	ਇੱਥੇ ਤੁਸੀਂ multi - threaded program breakpoint ਵਿਕਲਪਾਂ ਦੇ ਲਈ ਸੇਟਿੰਗ ਬਦਲ ਸਕਦੇ ਹੋ ।
08:59	ਜਾਂ ਜਿਨ੍ਹਾਂ ਮੈਥਡਸ ਦਾ ਤੁਸੀਂ ਵਰਤੋਂ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹੋ, ਉਸ ਦੇ ਨਿਰਮਾਣ ਦੇ ਲਈ ਫਿਲਟਰ ਕਰੋ ।
09:07	ਹੁਣ ਨਿਰਧਾਰਤ ਕੰਮ ਦੇ ਲਈ
09:09	ਨਿਰਧਾਰਤ ਕੰਮ ਦੇ ਰੂਪ ਵਿੱਚ, ਆਪਣੇ ਪ੍ਰੋਗਰਾਮ ਵਿੱਚੋਂ ਕੋਈ ਵੀ ਲਵੋਂ, ਚੰਗਾ ਹੋਵੇਗਾ ਜੇ ਇਸ ਵਿੱਚ ਪਹਿਲਾਂ ਤੋਂ ਹੀ ਐਰਰਸ ਹੋਣ ।
09:16	ਜੇ ਨਹੀਂ, ਤਾਂ ਲਾਜਿਕ ਜਾਂ ਐਲਗੋਰਿਦਮ ਦੇ ਨਾਲ ਕੁੱਝ ਐਰਰਸ ਤੋਂ ਸ਼ੁਰੂ ਕਰੋ ।
09:20	ਕੋਡ ਵਿੱਚ breakpoints ਸੈੱਟ ਕਰੋ । ਆਮ ਤੌਰ ‘ਤੇ, ਤੁਸੀਂ ਫੰਕਸ਼ਨ ਦੇ ਕਾਲਿੰਗ ਪੁਆਇੰਟ ‘ਤੇ ਬ੍ਰੇਕ ਨੂੰ ਸੈੱਟ ਕਰਦੇ ਹੋ ਜਿਸ ‘ਤੇ ਤੁਹਾਨੂੰ ਐਰਰ ਦਾ ਸ਼ੱਕ ਹੁੰਦਾ ਹੈ ।
09:29	Use ਫੰਕਸ਼ਨ ਵਿੱਚ ਜਾਣ ਦੇ ਲਈ Step - Into ਦੀ ਵਰਤੋਂ ਕਰੋ ।
09:32	ਲਾਈਨ ਚਲਾਉਣ ਦੇ ਲਈ Step - Overs ਦੀ ਵਰਤੋਂ ਕਰੋ ਅਤੇ ਵੈਰੀਏਬਲ ਵਿੰਡੋ ਵਿੱਚ ਵੈਰੀਏਬਲ ਦੀ ਵੈਲਿਊ ਦਾ ਨਿਰੀਖਣ ਕਰਨ ਦੇ ਲਈ ਯਕੀਨੀ ਬਣਾਓ ।
09:41	ਐਰਰ ਨੂੰ ਪਛਾਣਨ ਅਤੇ ਠੀਕ ਕਰਨ ਵਿੱਚ ਤੁਹਾਡੀ ਮੱਦਦ ਦੇ ਲਈ ਕੁੱਝ watches ਜੋੜੋ ।
09:45	ਮੈਥਡ ਤੋਂ ਬਾਹਰ ਜਾਓ ।
09:48	ਤੁਹਾਡੇ ਅਗਲੇ breakpoint ‘ਤੇ ਪਹੁੰਚਣ ਤੱਕ ਜਾਰੀ ਰੱਖੋ ।
09:51	ਅਤੇ ਅਖੀਰ ਵਿੱਚ, debugger ਸੈਸ਼ਨ ਖ਼ਤਮ ਕਰੋ ਅਤੇ ਆਪਣੀ ਐਪਲੀਕੇਸ਼ਨ ਨੂੰ ਰਨ ਕਰੋ ।
09:57	ਇਸ ਟਿਊਟੋਰਿਅਲ ਵਿੱਚ ਅਸੀਂ netbeans debugger ਦੇ ਨਾਲ ਵਾਕਫ਼ ਹੋ ਗਏ ਹਾਂ ।
10:02	ਅਸੀਂ ਵੇਖਿਆ ਕਿ ਕਿਵੇਂ breakpoints ਅਤੇ watches ਨੂੰ ਸੈੱਟ ਕਰੀਏ ।
10:06	expressions ਜੋੜੋ, ਜਿਨ੍ਹਾਂ ਦੀ ਅਸੀਂ ਗਿਣਤੀ ਕਰਨਾ ਚਾਹੁੰਦੇ ਹਾਂ,ਜਦੋਂ ਕੋਡ ਰਨ ਹੋ ਰਿਹਾ ਹੋ ।
10:11	Step - Into, Step - Over, Step - Out [aur] Run - to - Cursor ਦੇ ਵਿਕਲਪਾਂ ਦੇ ਨਾਲ ਪ੍ਰੋਗਰਾਮ ਦੀ ਕਾਰਗੁਜ਼ਾਰੀ ਦਾ ਪਤਾ ਲਗਾਇਆ ।
10:19	ਇਹ ਵੀ ਵੇਖਿਆ ਕਿ ਐਡਵਾਂਸ debugging ਦੇ ਲਈ debugger ਨੂੰ ਕਿਵੇਂ ਕਾਂਫਿਗਰ ਕਰੀਏ ।
10:24	ਆਸ ਕਰਦੇ ਹਾਂ ਕਿ ਇਸ ਟਿਊਟੋਰਿਅਲ ਨੇ ਤੁਹਾਡਾ ਟੈਸਟਿੰਗ ਅਤੇ debugging ਕੰਮ ਵਿੱਚ ਬਹੁਤ ਸਾਰਾ ਸਮਾਂ ਬਚਾਇਆ ਹੋਵੇਗਾ ।
10:30	ਸਕ੍ਰੀਨ ‘ਤੇ ਦਿਖਾਈ ਦੇ ਰਹੇ ਹੇਠ ਲਿਖੇ ਲਿੰਕ ‘ਤੇ ਉਪਲੱਬਧ ਵੀਡੀਓ ਨੂੰ ਵੇਖੋ ।
10:33	ਇਹ ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਦਾ ਸਾਰ ਕਰਦਾ ਹੈ ।
10:36	ਚੰਗੀ ਬੈਂਡਵਿਡਥ ਨਾ ਮਿਲਣ ‘ਤੇ ਤੁਸੀਂ ਇਸਨੂੰ ਡਾਊਂਨਲੋਡ ਕਰਕੇ ਵੀ ਵੇਖ ਸਕਦੇ ਹੋ ।
10:41	ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਟੀਮ, ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲਸ ਦੀ ਵਰਤੋਂ ਕਰਕੇ ਵਰਕਸ਼ਾਪਾਂ ਚਲਾਉਂਦੀ ਹੈ ।
10:46	ਆਨਲਾਇਨ ਟੈਸਟ ਪਾਸ ਕਰਨ ਵਾਲਿਆ ਨੂੰ ਪ੍ਰਮਾਣ ਪੱਤਰ ਵੀ ਦਿੰਦੇ ਹਨ ।
10:49	ਜ਼ਿਆਦਾ ਜਾਣਕਾਰੀ ਦੇ ਲਈ, ਕ੍ਰਿਪਾ ਕਰਕੇ contact@spoken-tutorial.org ‘ਤੇ ਲਿਖੋ ।
10:55	ਸਪੋਕਨ ਟਿਊਟੋਰਿਅਲ ਪ੍ਰੋਜੈਕਟ ਟਾਕ-ਟੂ-ਅ ਟੀਚਰ ਪ੍ਰੋਜੈਕਟ ਦਾ ਹਿੱਸਾ ਹੈ ।
10:59	ਇਹ ਭਾਰਤ ਸਰਕਾਰ ਦੇ ਐਮਐਚਆਰਡੀ ਦੇ “ਆਈਸੀਟੀ ਵਲੋਂ ਰਾਸ਼ਟਰੀ ਸਾਖਰਤਾ ਮਿਸ਼ਨ” ਦੁਆਰਾ ਪ੍ਰਮਾਣਿਤ ਹੈ ।
11:05	ਇਸ ‘ਤੇ ਜ਼ਿਆਦਾ ਜਾਣਕਾਰੀ ਹੇਠਾਂ ਦਿੱਤੇ ਲਿੰਕ ‘ਤੇ ਉਪਲੱਬਧ ਹੈ । http://spoken-tutorial.org/NMEICT-Intro
11:14	ਆਈ.ਆਈ.ਟੀ ਬੰਬੇ ਤੋਂ ਮੈਂ ਨਵਦੀਪ ਤੁਹਾਡੇ ਤੋਂ ਇਜਾਜ਼ਤ ਲੈਂਦਾ ਹਾਂ ।
11:18	ਸਾਡੇ ਨਾਲ ਜੁੜਣ ਦੇ ਲਈ ਧੰਨਵਾਦ ।

Contributors and Content Editors

Navdeep.dav