1
00:00:00,000 --> 00:00:11,420

2
00:00:11,420 --> 00:00:13,590
>> Tianyu ಲಯಿ: ಹೇ, ಹೇಗೆ
ಇದು ಎಲ್ಲರೂ ಹೋಗುವ?

3
00:00:13,590 --> 00:00:20,250
ಮತ್ತು ಈ ಐಒಎಸ್ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ
ಉದ್ದೇಶ ಸಿ ಸೆಮಿನಾರ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್.

4
00:00:20,250 --> 00:00:21,520
ನನ್ನ ಹೆಸರು Tianyu ಲಿಯು ಆಗಿದೆ.

5
00:00:21,520 --> 00:00:26,114
ನಾನು, ಇದೀಗ ಒಂದು ಲೊವೆಲ್ ಕಿರಿಯ ಮನುಷ್ಯ
ಕಂಪ್ಯೂಟರ್ ವಿಜ್ಞಾನದಲ್ಲಿ ಸಾಂದ್ರೀಕರಣ.

6
00:00:26,114 --> 00:00:28,030
ಆದ್ದರಿಂದ ಈ ವಿಚಾರಗೋಷ್ಠಿ ನಾನು
ಹೋಗುವ ನೀವು ಹುಡುಗರಿಗೆ ಕಲಿಸಲು

7
00:00:28,030 --> 00:00:30,770
ಅಪ್ಲಿಕೇಶನ್ ಮಾಡಲು ಹೇಗೆ ಬಗ್ಗೆ ಸ್ವಲ್ಪ.

8
00:00:30,770 --> 00:00:33,030
ವಾಹ್, ಇದು ಹರ್ಷ.

9
00:00:33,030 --> 00:00:36,790
>> ನಾವು ಕೂಡ ಡೈವಿಂಗ್ ಆರಂಭಿಸಲು ಮೊದಲು ಆದ್ದರಿಂದ
ನಿಜವಾದ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬದಿಯಲ್ಲಿ,

10
00:00:36,790 --> 00:00:41,840
ಬಗ್ಗೆ ಮಾತನಾಡಲು ತ್ವರಿತವಾಗಿ ಕೇವಲ ನಿಜವಾಗಿಯೂ ನ ಅವಕಾಶ
ಏಕೆ ನೀವು ಒಂದು ಐಒಎಸ್ ಅಪ್ಲಿಕೇಶನ್ ನಿರ್ಮಿಸಲು ಬಯಸಬಹುದು?

11
00:00:41,840 --> 00:00:43,940
ಏಕೆ ಐಒಎಸ್ ಆದ್ದರಿಂದ ಸ್ಪೂರ್ತಿದಾಯಕ?

12
00:00:43,940 --> 00:00:47,250
ಮೊದಲ ಸಮಸ್ಯೆ ಆದ್ದರಿಂದ, ಮೊದಲ
ನಮಗೆ ಬಹಳ ಉತ್ತಮವಾಗಿದೆ ಎಂದು ವಿಷಯ,

13
00:00:47,250 --> 00:00:51,190
ವಿಶೇಷವಾಗಿ ಒಂದು CS50 ಎಂದು
ವಿದ್ಯಾರ್ಥಿ, ಎಂದು ಐಒಎಸ್

14
00:00:51,190 --> 00:00:55,860
ಉದ್ದೇಶ ಸಿ ಸರಿ ಬಳಸುತ್ತದೆ, ಇಲ್ಲ
ಸ್ವಿಫ್ಟ್ ಎಂಬ ಹೊಸ ಭಾಷೆ,

15
00:00:55,860 --> 00:00:58,260
ಆದರೆ ನಾವು ಹೋಗುತ್ತಿಲ್ಲ
ಈ ವಿಚಾರಗೋಷ್ಠಿ ಬಳಸಲು.

16
00:00:58,260 --> 00:01:01,540
ನೀವು, ಸ್ವಿಫ್ಟ್ ಆಕ್ತಿಹೊಂದಿದ್ದರೆ
ಆ ಬಗ್ಗೆ ಸ್ವತಂತ್ರ ವಿಚಾರಗೋಷ್ಠಿ.

17
00:01:01,540 --> 00:01:05,590
ಆದರೆ ಉದ್ದೇಶ ಸಿ ಮೂಲತಃ
ಸಿ ಮೀನಿಂಗ್ ಸೂಪರ್ಸೆಟ್

18
00:01:05,590 --> 00:01:10,230
ನೀವು ಸಿ ಬಳಸುವ ಎಲ್ಲವನ್ನೂ
ಉದ್ದೇಶ ಸಿ ಭಾಷಾಂತರಿಸಲಾಯಿತು

19
00:01:10,230 --> 00:01:11,630
ಬಹಳ ಸುಲಭವಾಗಿ.

20
00:01:11,630 --> 00:01:15,730
>> ನೀವು ನಂತರ, ವಾಸ್ತವವಾಗಿ ನೋಡಿ ಹೆಳುವಂತೆ
ಕೆಲವು ಅತ್ಯಂತ ಮೂಲಭೂತ ವಾಕ್ಯ ಇವೆ ಇವೆ

21
00:01:15,730 --> 00:01:19,790
ಮೂಲತಃ ಒಂದೇ,
ಸಿ ಮತ್ತು ಉದ್ದೇಶ ಸಿ,

22
00:01:19,790 --> 00:01:22,860
ನೀವು CS50 ತೆಗೆದುಕೊಂಡ ನಂತರ
ಈ ದೂರದ, ನೀವು ಈಗಾಗಲೇ

23
00:01:22,860 --> 00:01:26,500
, ಕನಿಷ್ಠ 40% ಉದ್ದೇಶ ಸಿ ಗೊತ್ತಿಲ್ಲ.

24
00:01:26,500 --> 00:01:30,720
ಅಲ್ಲದೆ, ಆಪಲ್ ನಿಜವಾಗಿಯೂ ಹೊಂದಿದೆ
ಐಒಎಸ್ ದೃಢವಾದ API.

25
00:01:30,720 --> 00:01:33,750
ನಿಜವಾಗಿಯೂ ಕ್ರೇಜಿ ಬಹಳಷ್ಟು ಇವೆ
ವಿಷಯಗಳನ್ನು ನೀವು ಇದನ್ನು ಮಾಡಬಹುದು.

26
00:01:33,750 --> 00:01:36,760
ಇದು ಒಂದು ಯಾರಾದರೂ ಆಗಿದೆ
ವಾಸ್ತವವಾಗಿ ಒಂದು ಐಒಎಸ್ ಅಪ್ಲಿಕೇಶನ್

27
00:01:36,760 --> 00:01:40,600
ನಿಯಂತ್ರಿಸುವ ಕಾರುಗಳು, ಇದು
ಬಹಳ ಕುತೂಹಲಕಾರಿಯಾಗಿದೆ.

28
00:01:40,600 --> 00:01:42,610
ಬಹುಶಃ ಒಂದು ಹೆಲಿಕಾಪ್ಟರ್ ರೋಮಾಂಚನಕಾರಿ ಆಗಿದೆ.

29
00:01:42,610 --> 00:01:47,020
ಆದರೆ ಎಷ್ಟು ಪ್ರಬಲ ಇಲ್ಲಿದೆ
ಐಒಎಸ್ API ಮಾಡಬಹುದು.

30
00:01:47,020 --> 00:01:49,340
>> ಮತ್ತು ನೀವು ಹೊಂದಿರಬಹುದು
ಇದೀಗ ಕಾಣಿಸಿಕೊಂಡಿತ್ತು,

31
00:01:49,340 --> 00:01:53,000
ಸ್ಟಾಕ್ ಉಕ್ಕಿ ಬಹುಶಃ ಒಂದಾಗಿದೆ
ಪ್ರಮುಖ ಆನ್ಲೈನ್ ಸಂಪನ್ಮೂಲಗಳು

32
00:01:53,000 --> 00:01:54,250
ನೀವು ಲಭ್ಯವಿರುವ.

33
00:01:54,250 --> 00:01:58,090
ಮತ್ತು ಒಳ್ಳೆಯ ಸುದ್ದಿ, ಪ್ರತಿ
ನೀವು ಬಹುಶಃ ಮಾಡಬಹುದು ಒಂದು ಸಮಸ್ಯೆ

34
00:01:58,090 --> 00:02:01,840
ನಿರ್ಮಿಸುವಾಗ ನಗರದ ನಿಮ್ಮ
ಉದ್ದೇಶ ಸಿ ಅಂತಿಮ ಯೋಜನೆ,

35
00:02:01,840 --> 00:02:05,910
ಸ್ಟಾಕ್ ಉಕ್ಕಿ ಉತ್ತರವನ್ನು ಸಾಧ್ಯತೆ ಇಲ್ಲ.

36
00:02:05,910 --> 00:02:07,420
ಇದು ಕೇವಲ ಉತ್ತಮವಾಗಿದೆ.

37
00:02:07,420 --> 00:02:12,780
ಅದಕ್ಕೆ ಜೊತೆಯಾಗಿ,
ಐಒಎಸ್ ನಿಜವಾಗಿಯೂ ಒಂದು ವೇದಿಕೆಯಾಗಿದೆ

38
00:02:12,780 --> 00:02:16,260
ನೀವು ಒಂದು ದೊಡ್ಡ ತಲುಪಬಹುದು ಅಲ್ಲಿ
ಸ್ವಲ್ಪ ಪ್ರಯತ್ನ ಪ್ರೇಕ್ಷಕರು.

39
00:02:16,260 --> 00:02:20,170
ಇದು ಆಂಡ್ರಾಯ್ಡ್, ಅಲ್ಲಿ ಎಂದು ಅಲ್ಲ
ಎಲ್ಲವೂ ಬಹಳ ಛಿದ್ರಗೊಂಡ.

40
00:02:20,170 --> 00:02:22,540
>> ಎಲ್ಲವೂ ಐಒಎಸ್ ಏಕೀಕೃತ ಆಗಿದೆ.

41
00:02:22,540 --> 00:02:25,920
ಮತ್ತು ಅಲ್ಲಿಯವರೆಗೆ ನೀವು ರಚಿಸಲು
ಒಂದು ಐಫೋನ್ ಒಂದು ಅಪ್ಲಿಕೇಶನ್,

42
00:02:25,920 --> 00:02:31,260
ನೀವು ಅತ್ಯಂತ ಸುಲಭವಾಗಿ ಬಂದರು ಐಪ್ಯಾಡ್ ಎಂದು,
ಐಪ್ಯಾಡ್ ಮಿನಿ, ಅಥವಾ ವಿವಿಧ ಐಫೋನ್ ಗಾತ್ರಗಳು.

43
00:02:31,260 --> 00:02:33,050
ಈ ಎಲ್ಲಾ ನಿಜವಾಗಿಯೂ ಅನುಕೂಲಕರ.

44
00:02:33,050 --> 00:02:36,430
ಮತ್ತು ಇದು ಕೇವಲ ನಿಜವಾಗಿಯೂ ಒಳ್ಳೆಯದು
ನಿಮ್ಮ ಸ್ನೇಹಿತರು ಇಷ್ಟವಾಗುತ್ತದೆ.

45
00:02:36,430 --> 00:02:38,920
ನೀವು ಒಂದು ಐಫೋನ್ ಹಿಡಿಸುವ
ಮತ್ತು, ಹೇ ನಿಮ್ಮ ಸ್ನೇಹಿತರಿಗೆ ತಿಳಿಸಿ

46
00:02:38,920 --> 00:02:40,250
ಈ ನಾನು ಮಾಡಲು ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ.

47
00:02:40,250 --> 00:02:43,860
ನೀವು ಯಾವುದೇ ಹಾಗೆ ಮಾಡಬಹುದು
ಸಂತೋಷವನ್ನು ಇದು ಡೆಸ್ಕ್ಟಾಪ್ ಅಪ್ಲಿಕೇಶನ್ಗಳು,.

48
00:02:43,860 --> 00:02:48,870
>> ಸರಿ, ಈಗ ನಿಜವಾಗಿಯೂ ಪಡೆಯಲು ಅವಕಾಶ
ಭಾಷೆ ಉದ್ದೇಶ ಸಿ ಆಗಿ

49
00:02:48,870 --> 00:02:52,910
ಆದ್ದರಿಂದ ನಾವು ಪ್ರಾರಂಭವಾಗಲು
ಕೆಲವು ನಿಜವಾಗಿಯೂ ಮೂಲ ವಾಕ್ಯರಚನೆಯನ್ನು.

50
00:02:52,910 --> 00:02:57,410
ನಾನು ಉದ್ದೇಶ ಮೊದಲೇ ಹೇಳಿದಂತೆ
ಸಿ ಇದು ಸಿ ಮೂಲತಃ ಸೂಪರ್ಸೆಟ್ ಇಲ್ಲಿದೆ

51
00:02:57,410 --> 00:03:01,860
ಆದ್ದರಿಂದ ಮೂಲ ವಾಕ್ಯ ಸಾಕಷ್ಟು ಇವೆ
ವಾಸ್ತವವಾಗಿ ಒಂದೇ.

52
00:03:01,860 --> 00:03:06,150
ಮಾರ್ಪಡಿಸಬಹುದಾದ ಘೋಷಿಸುವ ಮತ್ತು
ಎರಡು ವ್ಯತ್ಯಾಸಗಳ ಒಟ್ಟಿಗೆ ಸೇರಿಸುವ

53
00:03:06,150 --> 00:03:09,440
ನಾವು ಮಾರಿಯೋ ಮಾಡಿದಂತೆಯೇ ನಿಖರವಾಗಿ.

54
00:03:09,440 --> 00:03:11,140
ಇಲ್ಲಿ ಹೊಸ ನಥಿಂಗ್.

55
00:03:11,140 --> 00:03:17,370
>> ಲೂಪ್ ಹಾಗೆಯೇ, ನಿವಾಸಿ
ಮತ್ತು ಪರಿಸ್ಥಿತಿಯು ಒಂದೇ.

56
00:03:17,370 --> 00:03:22,370
ನೀವು ಕೇವಲ ಒಂದು ಲೂಪ್ ಮಾಡಬಹುದು
ಒಂದು ಮಾರಿಯೋ [ಕೇಳಿಸುವುದಿಲ್ಲ] ರಲ್ಲಿ ಮಾಡಲಿಲ್ಲ.

57
00:03:22,370 --> 00:03:26,280
ಮತ್ತು ನೀವು ಪರಿಸ್ಥಿತಿಗಳು ಮಾಡಬಹುದು
ಕೇವಲ ನೀವು

58
00:03:26,280 --> 00:03:29,240
ನಿಮ್ಮ ಹಿಂದಿನ ಪುಟ ಮಾಡುತ್ತಾ ಮಾಡಲಾಗಿದೆ.

59
00:03:29,240 --> 00:03:33,400
ಆದರೆ, ಉದ್ದೇಶ ಸಿ
, ಸಿ ಸಂಪೂರ್ಣವಾಗಿ ಅಲ್ಲ

60
00:03:33,400 --> 00:03:36,640
ಮತ್ತು ಏನೋ ಎಂದು
ವಿಲಕ್ಷಣ ರೀತಿಯ ಇದು ಸುಮಾರು.

61
00:03:36,640 --> 00:03:42,340
>> ಮೊದಲ ಒಂದಾಗಿದೆ ನೀವು ಆಗ ಆ
ಸಿ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮಾಡುವ, ನೀವು ಸಾಮಾನ್ಯವಾಗಿ ಕರೆ

62
00:03:42,340 --> 00:03:46,310
ಮತ್ತು ನಂತರ ಲೈಬ್ರರಿ ಹೆಸರನ್ನು.

63
00:03:46,310 --> 00:03:49,860
ಆದರೆ ಉದ್ದೇಶ ಸಿ ನೀವು ಆಮದು ಕರೆ.

64
00:03:49,860 --> 00:03:53,100
ಮೂಲತಃ, ಕಾರ್ಯವನ್ನು ಹೇಳುವ
ಕೇವಲ ವಿವಿಧ ಹೆಸರುಗಳು.

65
00:03:53,100 --> 00:03:55,940
ಮತ್ತು ತಂತಿಗಳು
ವಾಸ್ತವವಾಗಿ ಸ್ವಲ್ಪ ವಿಚಿತ್ರವಾಗಿ.

66
00:03:55,940 --> 00:03:58,250
ನೀವು ಮೊದಲ ನೋಡಬಹುದು
ವಿಲಕ್ಷಣ ರೀತಿಯ ವಿಷಯ

67
00:03:58,250 --> 00:04:04,190
ನೀವು ಸಾಕಷ್ಟು weird-- ಹೊಂದಿರುತ್ತವೆ
ಕ್ಷಮಿಸಿ ನೀವು ಸಾಕಷ್ಟು ವಿಲಕ್ಷಣ ಎನ್ಎಸ್ ಹೊಂದಿವೆ

68
00:04:04,190 --> 00:04:04,960
ಇಲ್ಲಿ ಸೈನ್.

69
00:04:04,960 --> 00:04:07,452

70
00:04:07,452 --> 00:04:09,160
ಮತ್ತು ಎರಡನೆಯ ವಿಷಯ
ಎಂದು ವಿಯರ್ಡ್ ಭಾಸವಾಗುತ್ತದೆ

71
00:04:09,160 --> 00:04:14,090
ನೀವು ಮೊದಲು ಸೈನ್ ಒಂದು ಹೊಂದಿವೆ ಇದೆ
ವಾಸ್ತವವಾಗಿ ವಾಕ್ಯವನ್ನು ಘೋಷಿಸಿ.

72
00:04:14,090 --> 00:04:19,209
ಆದ್ದರಿಂದ ಸೈನ್ ಮೂಲತಃ ಸೂಚಿಸುತ್ತದೆ
ಸ್ಟ್ರಿಂಗ್ ಸ್ಟ್ರಿಂಗ್ ಕೇವಲ ಎಂದು,

73
00:04:19,209 --> 00:04:20,880
ಇದು ವಾಸ್ತವವಾಗಿ ಒಂದು ವಸ್ತು.

74
00:04:20,880 --> 00:04:22,780
ನಾವು ವಿವರಿಸಲು ನೀನು
ಆ ನಂತರ ಆದ್ದರಿಂದ ಇಲ್ಲ

75
00:04:22,780 --> 00:04:25,800
ಪ್ಯಾನಿಕ್ ನೀವು ವೇಳೆ
ಅಂದರೆ ಏನು ಅರ್ಥ.

76
00:04:25,800 --> 00:04:29,980
ಮತ್ತು ಕನ್ಸೋಲ್ ಮುದ್ರಣ ಸ್ವಲ್ಪ
ವಿವಿಧ ಏಕೆಂದರೆ ನಾವು printf ಕರೆ ಸಿ,

77
00:04:29,980 --> 00:04:33,350
ಆದರೆ ಉದ್ದೇಶ ಸಿ ನಾವು [ಕೇಳಿಸುವುದಿಲ್ಲ] ಕರೆ.

78
00:04:33,350 --> 00:04:35,640
>> ನೀವು ಏನು ಚಕಿತಗೊಳಿಸುತ್ತದೆ ಇರಬಹುದು.

79
00:04:35,640 --> 00:04:38,070
ಎಂದು, printf ಮೂಲತಃ
ಕೇವಲ ಬೇರೆ ಭಾಷೆ.

80
00:04:38,070 --> 00:04:41,370
ಒಂದೇ ಬಳಕೆ,
ಒಂದೇ ಕಾರ್ಯವನ್ನು.

81
00:04:41,370 --> 00:04:44,060
ಸರಿ ಇದು ತಿರುಗಿದರೆ
ಉದ್ದೇಶ ಸಿ ವಾಸ್ತವವಾಗಿ

82
00:04:44,060 --> 00:04:50,040
ಎನ್ಎಸ್ ಬಹುತೇಕ ಎದುರು ಹೊಂದಿದೆ
ಎಲ್ಲವನ್ನೂ, ಪ್ರತಿ ಮೂಲ ಅಕ್ಷಾಂಶ ರೀತಿಯ,

83
00:04:50,040 --> 00:04:52,690
NSDictionary, NSArray, NSString.

84
00:04:52,690 --> 00:04:56,340
ಕಾರಣ ಎನ್ಎಸ್ ಎಂದು
ವಾಸ್ತವವಾಗಿ ಮುಂದಿನ ಹಂತ ಹೊಂದಲಾಗಿದೆ,

85
00:04:56,340 --> 00:04:59,980
ಒಂದು ಕಂಪನಿ ಎಂದು
ಸ್ಟೀವ್ ಜಾಬ್ಸ್, ಸ್ಥಾಪಿಸಿದ್ದಾರೆ

86
00:04:59,980 --> 00:05:03,960
ಒಂದು ಕಂಪನಿ ಇದು ಅಲ್ಲಿ
ಭಾಷೆ ಉದ್ದೇಶ ಸಿ ಜನನ ಇದೆ.

87
00:05:03,960 --> 00:05:06,140
ಆದ್ದರಿಂದ ಈ ಮೂಲತಃ ಸಂಪ್ರದಾಯವಾಗಿದೆ.

88
00:05:06,140 --> 00:05:09,010
ನಾನು ಸ್ವಲ್ಪ ಗೊತ್ತು
ವಿಲಕ್ಷಣ, ಆದರೆ ಇದು ಆಪಲ್.

89
00:05:09,010 --> 00:05:16,840
>> ಸಹ weirder ಆದ್ದರಿಂದ ಏನೋ
ಹೆಚ್ಚು ಕಾರ್ಯ ಘೋಷಣೆಯಾಗಿದೆ.

90
00:05:16,840 --> 00:05:22,600
ಈ ನಾವು ಏನು ಅತ್ಯಂತ ವಿಭಿನ್ನವಾಗಿದೆ
, ಸಿ ನೋಡಲು ಇಲ್ಲಿ ವಾಸ್ತವವಾಗಿ ಏಕೆಂದರೆ

91
00:05:22,600 --> 00:05:25,190
ಇನ್ನು ಮುಂದೆ ಸಿ ಕಂಡುಬರುತ್ತಿಲ್ಲ.

92
00:05:25,190 --> 00:05:28,810
ನೀವು ಮೂಲಕ ಇಲ್ಲಿ ಏನು
ಈ ಗುಂಡಿನ ಹಂತದಲ್ಲಿ ಅಲ್ಲ ರೀತಿಯಲ್ಲಿ,

93
00:05:28,810 --> 00:05:30,690
ಈ ಒಂದು ಮೈನಸ್ ಚಿಹ್ನೆ.

94
00:05:30,690 --> 00:05:36,440
ನೀವು ಮೈನಸ್ ಚಿಹ್ನೆ ಆವರಣದ
ಅನೂರ್ಜಿತ ಮತ್ತು ನಂತರ ಕ್ರಿಯೆ ಹೆಸರು.

95
00:05:36,440 --> 00:05:38,450
ಕೇವಲ ವೇಳೆ ಹೇಳುತ್ತಾರೆ ನಾವು
ನಂತರ, ಹಲೋ ವರ್ಲ್ಡ್ ಹೊಂದಿವೆ

96
00:05:38,450 --> 00:05:42,820
ರಿಟರ್ನ್ ರೀತಿಯ ಶೂನ್ಯವನ್ನು ಎಂದು
ನಾವು ಏನೂ ಮರಳಲು ಕಾರಣ.

97
00:05:42,820 --> 00:05:44,680
>> ಏನು ನಿಜವಾಗಿಯೂ ವಿಲಕ್ಷಣ ಪಡೆಯುತ್ತದೆ
ನೀವು ಇರುವಾಗ ಎಂದು

98
00:05:44,680 --> 00:05:49,580
ಒಂದಕ್ಕಿಂತ ಹೆಚ್ಚು ನಿಯತಾಂಕ ಹೊಂದಿರುವ
ಒಂದು ಅದೇ ಕಾರ್ಯ ಹಾದುಹೋಗುವ ಎಂದು

99
00:05:49,580 --> 00:05:53,870
ಇಲ್ಲಿ ತೋರಿಸಲಾಗಿದೆ ನಿಜವಾಗಿಯೂ ವಿಲಕ್ಷಣ ಇರುತ್ತದೆ.

100
00:05:53,870 --> 00:05:58,230
ನಾವು ಒಂದು ವಿಧಾನ ಹೆಸರನ್ನು ಹೊಂದಿವೆ,
ಎಂದು addInt [ಕೇಳಿಸುವುದಿಲ್ಲ]

101
00:05:58,230 --> 00:06:00,370
ಮತ್ತು ನಾವು ಒಂದು ನಿಯತಾಂಕ ಹಾದುಹೋಗುವ ನೀವು.

102
00:06:00,370 --> 00:06:05,170
ಆದರೆ ಆ ನಂತರ, ನಾವು
ಹೆಚ್ಚು ಹೆಸರು ವಿಧಾನ ಕರೆ.

103
00:06:05,170 --> 00:06:08,500
ಮತ್ತು ನಂತರ ನಾವು ಹಾದುಹೋಗುವ ನೀವು
ಎರಡನೇ ನಿಯತಾಂಕವನ್ನು.

104
00:06:08,500 --> 00:06:11,940
ಈ, ವಾಸ್ತವವಾಗಿ ಸ್ವಲ್ಪ ವಿಲಕ್ಷಣ
ಆದರೆ ಈ ಎಲ್ಲಾ ಕಾರ್ಯ ಘೋಷಣೆಗಳು

105
00:06:11,940 --> 00:06:14,770
ಈ ಅದೇ ಮಾದರಿಯನ್ನು ಅನುಸರಿಸಿ.

106
00:06:14,770 --> 00:06:17,450
>> ನಾವು ಆರಂಭದಲ್ಲಿ ಒಂದು ಮೈನಸ್ ಚಿಹ್ನೆ ಹೊಂದಿವೆ.

107
00:06:17,450 --> 00:06:21,550
ಮೈನಸ್ ಚಿಹ್ನೆ ಒಂದು ಪ್ಲಸ್ ಸೈನ್ ಆಗಿರಬಹುದು
ಕೆಲವೊಮ್ಮೆ ವಿಧಾನ ಯಾವ ರೀತಿಯ ಆಧರಿಸಿ

108
00:06:21,550 --> 00:06:22,340
ಅದು.

109
00:06:22,340 --> 00:06:25,000
ವಿಧಾನ ಮೂಲತಃ
ಕ್ರಿಯೆಯ ಇನ್ನೊಂದು ಹೆಸರು.

110
00:06:25,000 --> 00:06:26,760
ಮತ್ತು ನಾವು ನೀನು
ವಿವರಿಸುವ ನಂತರ ಯಾವಾಗ

111
00:06:26,760 --> 00:06:30,580
ನಾವು ವಸ್ತುವಿನ ಬಗ್ಗೆ ನೀವು
ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್.

112
00:06:30,580 --> 00:06:34,300
ನೀವು ಮೊದಲ ಆದಾಯದ ಸೂಚಿಸಿ
, ಒಳಗೆ ಆವರಣ ಟೈಪ್

113
00:06:34,300 --> 00:06:37,450
ನಂತರ ವಿಧಾನ ಹೆಸರು ಬರುತ್ತದೆ.

114
00:06:37,450 --> 00:06:40,310
ನೀವು ಒಂದು ನಿಯತಾಂಕ ಹಾದುಹೋಗುವ ನೀವು.

115
00:06:40,310 --> 00:06:44,750
ಮತ್ತು ನೀವು ಹೆಚ್ಚು ನಿಯತಾಂಕಗಳನ್ನು ಹೊಂದಿದ್ದರೆ
ನೀವು ವಿಧಾನವನ್ನು ಹೆಸರು ವಿಸ್ತರಿಸಲು ಅಗತ್ಯವಿದೆ

116
00:06:44,750 --> 00:06:46,770
ಮತ್ತು ಮೂಲತಃ ಹೆಚ್ಚು ಇಲ್ಲಿ ಏನನ್ನಾದರೂ ಬರೆಯಲು.

117
00:06:46,770 --> 00:06:48,090
>> ಇದು ನೀವು ಏನು ಮಾಡಬಹುದು.

118
00:06:48,090 --> 00:06:50,140
ನಮ್ಮ ವಿಷಯದಲ್ಲಿ ಇದು ಇಲ್ಲಿದೆ.

119
00:06:50,140 --> 00:06:56,160
ಆದರೆ ನೀವು ಹೇಳಬಹುದು ಕೊನೆಯಲ್ಲಿ, ಅಥವಾ ಅಥವಾ, ಅಥವಾ
ನೀವು ಬಯಸುವ ಯಾವುದೇ ಎಬಿಸಿ ಪೂರ್ಣ ಬಾರ್,.

120
00:06:56,160 --> 00:06:59,500
ಮತ್ತು ಆ ನಂತರ ನೀವು ಆರ್
ನಿಯತಾಂಕ ಬಿ ಹಾದುಹೋಗುವ.

121
00:06:59,500 --> 00:07:01,750
ಈ ನಿಜವಾಗಿಯೂ ವಿಲಕ್ಷಣ ಆಗಿದೆ
ಸಮಾವೇಶ ಆದರೆ ನಾವು

122
00:07:01,750 --> 00:07:05,800
ಆಪಲ್ ಬಯಸುತ್ತೇನೆ ಏಕೆ ನೋಡಲು ಹೋಗುವ
ಬೇಗನೆ ಹಾಗೆ.

123
00:07:05,800 --> 00:07:10,530
ಆದ್ದರಿಂದ ಹೇಗೆ ನೀವು ಕಾರ್ಯ ಕರೆ ಮಾಡಬೇಡಿ?

124
00:07:10,530 --> 00:07:15,520
ಉದ್ದೇಶ ಒಂದು ಕ್ರಿಯೆ ಕರೆ
ಸಿ ಸಹ ಸಿ ಭಿನ್ನವಾಗಿದೆ

125
00:07:15,520 --> 00:07:18,170
>> ವಾಸ್ತವವಾಗಿ, ಕರೆ
ಉದ್ದೇಶ ಸಿ ಕಾರ್ಯ

126
00:07:18,170 --> 00:07:21,030
ನೀವು ಯಾರಿಗಾದರೂ ಮಾತನಾಡುವ ಮಾಡುತ್ತಿರುವಂತೆ ಹೆಚ್ಚು.

127
00:07:21,030 --> 00:07:27,030
ಇಲ್ಲಿ ನಾವು ಸ್ವಯಂ, ಹೊಂದಿರುವ
ವಸ್ತು ಕರೆಯಲಾಗುತ್ತದೆ.

128
00:07:27,030 --> 00:07:33,830
ನೀವು ಮೂಲತಃ ಹೇಳುತಿದ್ದಾರೆ
ಹೇಳಲು ಸ್ವಯಂ ವಸ್ತು "ಹಲೋ ವರ್ಲ್ಡ್!"

129
00:07:33,830 --> 00:07:36,830
ಆ ಕಾರ್ಯವನ್ನು ಕರೆ ಹೇಗೆ.

130
00:07:36,830 --> 00:07:41,690
ವಸ್ತು ಮತ್ತು ವಿಧಾನ ಹೆಸರು
ಪರಸ್ಪರ ಸೇರಿಕೊಂಡು.

131
00:07:41,690 --> 00:07:49,600
ಮತ್ತು ಈ ಅಲ್ಲಿ ವಿಲಕ್ಷಣ ವಿಸ್ತರಣೆಯಾಗಿದೆ
ವಿಧಾನ ಹೆಸರು ನಿಜವಾಗಿಯೂ ಕಾರ್ಯರೂಪಕ್ಕೆ ಬರುತ್ತದೆ.

132
00:07:49,600 --> 00:07:52,150
>> ಎರಡನೇ ಉದಾಹರಣೆಯನ್ನು ನೋಡೋಣ.

133
00:07:52,150 --> 00:07:56,780
ನಾವು ಎಂಬ ವಿಧಾನವನ್ನು ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ
addInt ಜೊತೆ blah blah blah.

134
00:07:56,780 --> 00:08:00,066
ನೀವು ಕರೆ ಮಾಡಿದಾಗ ಈ ಸಂದರ್ಭದಲ್ಲಿ
ನಿರ್ದಿಷ್ಟ [? ಸಂದೇಶವನ್ನು?] ಇದು ವಿಶೇಷವೇನು

135
00:08:00,066 --> 00:08:02,035
ಸ್ವಯಂ addInt ಕಾಣುವಂತೆ: 10: 2.

136
00:08:02,035 --> 00:08:05,410

137
00:08:05,410 --> 00:08:08,070
ಇದು ಇಂಗ್ಲೀಷ್ ರೀತಿಯಲ್ಲಿ ಧ್ವನಿಸುತ್ತದೆ.

138
00:08:08,070 --> 00:08:11,980
ಕಾರ್ಯ ಸಹ
ಕಾರ್ಯ ಘೋಷಣೆ, ವಿಲಕ್ಷಣ

139
00:08:11,980 --> 00:08:15,600
ಉದ್ದೇಶ ಸಿ ನ ಪಾಯಿಂಟ್
ವಿಧಾನ ಘೋಷಣೆ ಮಾದರಿಯನ್ನು,

140
00:08:15,600 --> 00:08:18,830
ನೀವು ಕರೆ ಮಾಡಿದಾಗ ಎಂಬುದು
ಕಾರ್ಯ ಅಥವಾ ವಿಧಾನ

141
00:08:18,830 --> 00:08:21,980
ಇದು ನಿಜವಾದ ಇಂಗ್ಲೀಷ್ ಧ್ವನಿ ಕಾಣಿಸುತ್ತದೆ.

142
00:08:21,980 --> 00:08:25,270
ಆದ್ದರಿಂದ ಇದು ಬಹಳ ಅರ್ಥಗರ್ಭಿತ
ನೀವು ಮನಸ್ಸು.

143
00:08:25,270 --> 00:08:28,740
>> ವಿಶೇಷವಾಗಿ ಈ ಸಂದರ್ಭದಲ್ಲಿ,
ಅಲ್ಲಿ ನೀವು ಮೂಲತಃ ಮಾಡಬಹುದು

144
00:08:28,740 --> 00:08:33,010
ಕ್ರಿಯೆ ಹೆಸರು ಎಂದು ನೋಡಿ
ರೀತಿಯ ಸ್ವತಃ ದಾಖಲಿಸುವ.

145
00:08:33,010 --> 00:08:35,390
ನೀವು ಯಾವುದೇ ಅಗತ್ಯವಿಲ್ಲ
ಹೆಚ್ಚು ವಿವರಣೆ ನೋಡಲು

146
00:08:35,390 --> 00:08:42,770
ನಿಖರವಾಗಿ ಏನು ನಡೆಯುತ್ತಿದೆ, ಏನು
ನಿಖರವಾಗಿ ಒಂದು ನಿಯತಾಂಕ ಮಾಡುವ.

147
00:08:42,770 --> 00:08:48,470
ಆ ಮೀರಿ, ನ ಸ್ವಲ್ಪ ಮಾತನಾಡೋಣ
ವಸ್ತು ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ಬಗ್ಗೆ ಸ್ವಲ್ಪ.

148
00:08:48,470 --> 00:08:52,160
ವಸ್ತು ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ಆಗಿದೆ
ಮೂಲಭೂತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಒಂದು

149
00:08:52,160 --> 00:08:57,110
ಎಂದು ತಂತ್ರಗಳನ್ನು ಅಥವಾ ಮಾದರಿಗಳನ್ನು
ಉದ್ದೇಶ ಸಿ ಉದ್ದೇಶ ಸಿ ಬಳಸುವ

150
00:08:57,110 --> 00:09:03,110
ಉದ್ದೇಶ ಸಿ ಅಲ್ಲದ ಕರೆಯಲಾಗುತ್ತದೆ
ಸಿ, ಒಳ್ಳೆಯ ಕಾರಣಕ್ಕಾಗಿ.

151
00:09:03,110 --> 00:09:07,560
>> ನಾವು ಬರಲು ಮೊದಲು ಆದ್ದರಿಂದ
ಉದ್ದೇಶ ಸಿ ವಾಕ್ಯ,

152
00:09:07,560 --> 00:09:11,670
ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ನೋಡೋಣ
ನಿಖರವಾಗಿ ಒಂದು ವಸ್ತು.

153
00:09:11,670 --> 00:09:15,480
ನಾವು ಬಹುಶಃ ಏನೋ ಮಾಡಿದ
, ಮೊದಲು ವಸ್ತುವಿನ ರೀತಿಯಲ್ಲಿ ಇದು

154
00:09:15,480 --> 00:09:19,780
ನೀವು ಆಗ struct ಕರೆಯಲಾಗುತ್ತದೆ
ಒಂದು ಮರದ ಅಥವಾ ಒಂದು ಲಿಂಕ್ ಪಟ್ಟಿ ಅನುಷ್ಠಾನಕ್ಕೆ

155
00:09:19,780 --> 00:09:25,730
ಅಥವಾ [? ಪ್ರಯತ್ನಿಸಿ. ?] ಆದ್ದರಿಂದ, ಇದು
ಮೂಲತಃ struct ಹಾಗೆ,

156
00:09:25,730 --> 00:09:28,560
ಆದರೆ ಇದು ಹೆಚ್ಚು ಶಕ್ತಿಶಾಲಿ ಹೆಚ್ಚು ಇಲ್ಲಿದೆ.

157
00:09:28,560 --> 00:09:33,150
ವಸ್ತುವಿನ ವಿಧಾನಗಳು ಮತ್ತು ಗುಣಗಳನ್ನು ಹೊಂದಿದೆ.

158
00:09:33,150 --> 00:09:35,310
ವಿಧಾನಗಳು ಮೂಲತಃ ಕ್ರಿಯೆಗಳು.

159
00:09:35,310 --> 00:09:39,480
ಮೂಲತಃ ಒಂದು ಕಾರ್ಯಗಳ
ಒಂದು ನಿರ್ದಿಷ್ಟ ವಸ್ತುವಿನ ನಿರ್ದಿಷ್ಟ.

160
00:09:39,480 --> 00:09:45,440
>> ಮತ್ತು ಗುಣಗಳನ್ನು ಮೂಲತಃ
ಕ್ಷೇತ್ರದಲ್ಲಿ ನೀವು struct ಸೂಚಿಸಿ.

161
00:09:45,440 --> 00:09:48,500
ಪ್ರತಿಯೊಂದು ವಸ್ತುವಿನ ಹಾಗೆ
ನಾವು ಕೆಲವು ಆಸ್ತಿ ಹೊಂದಿವೆ

162
00:09:48,500 --> 00:09:53,160
ಕೆಲವು ಅಸ್ಥಿರ ಹೊಂದಿರುವ
ವಸ್ತು ನಿರ್ದಿಷ್ಟವಾದ.

163
00:09:53,160 --> 00:09:57,170
ಮತ್ತು ನಾವು ಕೆಲವು ಕಾರ್ಯಗಳನ್ನು ಇದು
ವಸ್ತುವಿನ ನಿರ್ದಿಷ್ಟವಾದ.

164
00:09:57,170 --> 00:10:01,180
ಮತ್ತು ಕಾರ್ಯಗಳನ್ನು ವಿಧಾನಗಳು ಕರೆಯಲಾಗುತ್ತದೆ
ಮತ್ತು ಅಸ್ಥಿರ ಗುಣಗಳು ಎಂದು.

165
00:10:01,180 --> 00:10:03,190
ಇದು ಒಂದು ಅಲಂಕಾರಿಕ ಹೆಸರು ಇಲ್ಲಿದೆ.

166
00:10:03,190 --> 00:10:10,440
ನೀವು ವಾಸ್ತವವಾಗಿ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರತಿಯೊಂದು ವೀಕ್ಷಿಸಿ
ನೀವು ಒಂದು ಐಒಎಸ್ ಅಪ್ಲಿಕೇಶನ್ ತೆರೆಯಲು ನೀವು, ನೋಡಿ

167
00:10:10,440 --> 00:10:17,720
, ಕೇವಲ ಟ್ವಿಟರ್ ಅಥವಾ ಫೇಸ್ಬುಕ್ ಹೇಳಿ
ನೀವು ನೋಡಿ ಪ್ರತಿಯೊಂದು ವೀಕ್ಷಿಸಿ ಒಂದು ವಸ್ತು.

168
00:10:17,720 --> 00:10:22,110
ಮತ್ತು ಸಂಪೂರ್ಣ ಅಪ್ಲಿಕೇಶನ್ ಆಗಿದೆ
ವಸ್ತು ಆರಂಭವಾಗಬೇಕು.

169
00:10:22,110 --> 00:10:25,340
ಕುತೂಹಲಕಾರಿ ಪರಿಕಲ್ಪನೆ.

170
00:10:25,340 --> 00:10:28,480
>> ಮತ್ತು ಏಕೆ ನಾವು ವಸ್ತುವಿನ ಬಯಸುತ್ತೀರಿ
ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಆಧಾರಿತ?

171
00:10:28,480 --> 00:10:33,530
ನೀವು ಊಹಿಸುವ ಹಾಗೆ ಮಾಡಿದಾಗ ನೀವು
ಪ್ರೋಗ್ರಾಂ ಇದು ಬಹಳ ಸಂಕೀರ್ಣವಾದ ಪಡೆಯುತ್ತದೆ.

172
00:10:33,530 --> 00:10:36,400
ಕೇವಲ ನೀವು ಇರುವಾಗ ಹೇಳುತ್ತಾರೆ
ಚದುರಂಗ ಫಲಕದ ಅನುಷ್ಠಾನಕ್ಕೆ,

173
00:10:36,400 --> 00:10:40,020
ತರ್ಕ ಹೋಗುತ್ತದೆ
ನಿಜವಾಗಿಯೂ ಕ್ಲಿಷ್ಟಕರ.

174
00:10:40,020 --> 00:10:43,280
ನೀವು 36 ವಿವಿಧ ಹೊಂದಿವೆ
ತುಣುಕುಗಳನ್ನು, ಎಂದು, ಆದ್ದರಿಂದ ನೀವು

175
00:10:43,280 --> 00:10:48,370
ಎಲ್ಲಾ ತರ್ಕ ಬರೆಯಲು ಬಯಸುವ
ಚದುರಂಗದ 36 ವಿವಿಧ ಕಾಯಿಗಳು

176
00:10:48,370 --> 00:10:52,150
ಎಂದು ಬಹಳಷ್ಟು ಎಂದು ವಿಶೇಷವೇನು
ವಿವಿಧ ಕಾರ್ಯಗಳನ್ನು ಮತ್ತು ಅಸ್ಥಿರ.

177
00:10:52,150 --> 00:10:54,070
ಇದು ತೊಂದರೆ ಬಹಳಷ್ಟು ಇಲ್ಲಿದೆ.

178
00:10:54,070 --> 00:10:58,980
ಮತ್ತು ಬಹುಶಃ ನೀವು ಬರೆಯಲು ನೀನು
ವಿವಿಧ ವಿಧಾನ ಅಥವಾ ಬೇರೆ ಕಾರ್ಯ

179
00:10:58,980 --> 00:11:03,950
ತುಂಡು ಪ್ರತಿಯೊಂದು
ನಿಖರವಾಗಿ ಅವರು ಏನು ನಿಯಂತ್ರಿಸಲು.

180
00:11:03,950 --> 00:11:08,830
>> ನೀವು ವೇಳೆ ವಸ್ತು ಆಧಾರಿತ
ಪ್ರೋಗ್ರಾಮಿಂಗ್, ಈ ಎಲ್ಲಾ ಕಾಯಿಗಳನ್ನು

181
00:11:08,830 --> 00:11:12,440
ಆಗಿ ಅಮೂರ್ತ ಮಾಡಬಹುದು
ಒಂದೇ ವಸ್ತು.

182
00:11:12,440 --> 00:11:16,111
ಮತ್ತು ವಸ್ತು ಕೆಲವು ಸಾಮಾನ್ಯ ಹೊಂದಿರುತ್ತದೆ
ತುಂಡು ಯಾವ ರೀತಿಯ ಗುಣಗಳನ್ನು,

183
00:11:16,111 --> 00:11:16,610
ಅದು?

184
00:11:16,610 --> 00:11:17,740
ಇದು ಯಾವ ಬಣ್ಣ?

185
00:11:17,740 --> 00:11:19,480
ಇದು ಹೇಗೆ ಚಲಿಸಬಹುದು?

186
00:11:19,480 --> 00:11:24,660
ಮತ್ತು ಆ ರೀತಿಯಲ್ಲಿ ನೀವು ಬಹಳವಾಗಿ ಹೊಂದಿವೆ
ತರ್ಕ ಸರಳೀಕೃತ.

187
00:11:24,660 --> 00:11:28,480
ಆದ್ದರಿಂದ ಕೇವಲ ಒಳ್ಳೆಯ ಮಾರ್ಗವಾಗಿದೆ
ಸಂಕೀರ್ಣವಾದ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಮಾಡಲು,

188
00:11:28,480 --> 00:11:33,700
ಮತ್ತು ಶ್ರೇಣಿಕೃತ ಸಂಬಂಧವನ್ನು
ಪ್ರೋಗ್ರಾಂ, ಸರಳ.

189
00:11:33,700 --> 00:11:36,800
ನಾವು ನೋಡಲು ನೀನು
ಏಕೆ ಬೇಗನೆ ಮಾಡಿದಾಗ

190
00:11:36,800 --> 00:11:39,660
ನಾವು ವಾಸ್ತವವಾಗಿ ಮಾಡುತ್ತಿರುವುದು
ನಾವು ವಾಸ್ತವವಾಗಿ ಇರುವಾಗ ಪ್ರೋಗ್ರಾಮಿಂಗ್

191
00:11:39,660 --> 00:11:42,830
ಒಂದು ಎಸ್ ಕೋಡ್ ಮಾಡುವ
ನಂತರ ಅಧಿವೇಶನ ಪ್ರೋಗ್ರಾಮಿಂಗ್.

192
00:11:42,830 --> 00:11:48,120
>> ಅಲ್ಲದೆ ಜೊತೆಗೆ,
ವಸ್ತು ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್

193
00:11:48,120 --> 00:11:50,030
ಮೋಜಿನ ಸಾಕಷ್ಟು ಆಗಿದೆ.

194
00:11:50,030 --> 00:11:51,990
ನೀವು ನಿಮ್ಮ ಸ್ವಂತ ವಸ್ತು ವಿನ್ಯಾಸ ಸಿಕ್ಕಿತು.

195
00:11:51,990 --> 00:11:56,080
ನೀವು ಏನು ವಿನ್ಯಾಸ ಸಿಕ್ಕಿತು
ಇದು ನಿಮ್ಮ ಮೂಲಕ ರೀತಿ.

196
00:11:56,080 --> 00:11:58,250
ಇದು ಯಾವುದೇ ಸರಿಯಾದ ಉತ್ತರ ಇಲ್ಲ.

197
00:11:58,250 --> 00:12:02,940
ಮತ್ತು ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಆಸಕ್ತಿಕರವಾಗಿದೆ.

198
00:12:02,940 --> 00:12:07,270
ಆದ್ದರಿಂದ ವಸ್ತು ಆಧಾರಿತ ಪ್ರೊಗ್ರಾಮಿಂಗ್ ನಲ್ಲಿ,
ಎರಡು ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆಗಳು

199
00:12:07,270 --> 00:12:10,130
ವರ್ಗ ಮತ್ತು ಉದಾಹರಣೆಗೆ ಇರುತ್ತದೆ.

200
00:12:10,130 --> 00:12:13,570
ಒಂದು ವರ್ಗ ಮೂಲತಃ
ವಸ್ತು ಟೆಂಪ್ಲೆಟ್.

201
00:12:13,570 --> 00:12:18,070
ಮತ್ತು ಒಂದು ಉದಾಹರಣೆಗೆ ಮೂಲತಃ
ಒಂದು ನಿರ್ದಿಷ್ಟ ವಸ್ತು.

202
00:12:18,070 --> 00:12:21,090
>> ಕೇವಲ ನೀವು ಒಂದು ಕುಕಿ ಮಾಡುವ ನೀವು ಹೇಳಬಹುದು.

203
00:12:21,090 --> 00:12:24,800
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ಪ್ರತಿಯೊಂದು
ನೀವು ನಿಜವಾಗಿಯೂ ಅಂತ್ಯಗೊಳ್ಳುತ್ತಿತ್ತು ಕುಕೀ

204
00:12:24,800 --> 00:12:27,310
ವಸ್ತು ಏರಲಿದೆ.

205
00:12:27,310 --> 00:12:35,830
ಆದರೆ ಕುಕೀ ಪ್ಲೇಟ್ ನೀವು ತಯಾರಿಸಲು ಬಳಸಿ
ಎಲ್ಲಾ ಕುಕೀಸ್ ಒಂದು ವರ್ಗ ಇರುತ್ತದೆ.

206
00:12:35,830 --> 00:12:37,880
ಒಂದು ವರ್ಗ ಮೂಲತಃ ಒಂದು ಟೆಂಪ್ಲೇಟ್ ಆಗಿದೆ.

207
00:12:37,880 --> 00:12:46,170
ಮತ್ತು ಉದಾಹರಣೆಗೆ ಒಂದು ನಿರ್ದಿಷ್ಟ ಇರುತ್ತದೆ
ವಸ್ತು ವರ್ಗ ಸೃಷ್ಟಿಯಾಯಿತು.

208
00:12:46,170 --> 00:12:49,970
>> ಮತ್ತು ಒಂದು ಉದಾಹರಣೆಗೆ ನಿರ್ಮಿಸಲಾಗುತ್ತದೆ
ವರ್ಗ ಘೋಷಣೆ ಆಧರಿಸಿ,

209
00:12:49,970 --> 00:12:56,760
ನಾವು ನಂತರ ಸ್ಲೈಡ್ಗಳು ನೋಡುತ್ತಾರೆ.

210
00:12:56,760 --> 00:13:00,010
ಆದ್ದರಿಂದ ಅವರ ವಾಸ್ತವವಾಗಿ ನಿಜವಾಗಿಯೂ ಮಾಡಿ
ತ್ವರಿತ ಉದಾಹರಣೆಗೆ [ಕೇಳಿಸುವುದಿಲ್ಲ].

211
00:13:00,010 --> 00:13:04,280
ನಾವು ಘೋಷಿಸುವ ನೀವು ಹೇಳಬಹುದು
ಬೆಕ್ಕು ವಸ್ತು.

212
00:13:04,280 --> 00:13:07,930
ವಸ್ತು ಹೊಂದಬಹುದು ಬೇಕು
ಬೆಕ್ಕು ವರ್ಗ ಮಾಡಬೇಕು

213
00:13:07,930 --> 00:13:11,260
ಕೆಲವು ಗುಣಗಳನ್ನು ಮತ್ತು ವಿಧಾನಗಳನ್ನು ಹೊಂದಿವೆ.

214
00:13:11,260 --> 00:13:17,300
ಗುಣಗಳನ್ನು ಮಾಡಬೇಕು ಯಾವ ರೀತಿಯ
ವರ್ಗ ಹೊಂದಿರುತ್ತವೆ ಬೆಕ್ಕು ಇರಬೇಕು?

215
00:13:17,300 --> 00:13:20,580
>> ಉದಾಹರಣೆಗೆ, ಬಣ್ಣ,
ವಯಸ್ಸು ಮತ್ತು ತಳಿ, ಆ

216
00:13:20,580 --> 00:13:24,440
ಅಸ್ಥಿರ ಎಂಬುದನ್ನು
ಪ್ರತಿ ಬೆಕ್ಕು ನಿರ್ದಿಷ್ಟವಾದ.

217
00:13:24,440 --> 00:13:27,790
ಮತ್ತು ಆ ಕೆಲವು ವಸ್ತುಗಳು
ನಾವು ಬೆಕ್ಕು ವಿವರಿಸಲು ಬಳಸುವ.

218
00:13:27,790 --> 00:13:31,880
ವಿಧಾನ ಯಾವ ರೀತಿಯ,
ಅಥವಾ ಬೆಕ್ಕು ಏನು ಮಾಡಬಹುದು?

219
00:13:31,880 --> 00:13:37,160
ಕೆಲವು ತ್ವರಿತ ಉದಾಹರಣೆಗಳು ಚೇಸ್ ಎಂದು
ಮೌಸ್, ಮೀನು ತಿನ್ನಲು ಅಥವಾ ಮಿಯಾಂವ್.

220
00:13:37,160 --> 00:13:40,900
ಈ ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ
ಬೆಕ್ಕು ವರ್ಗದ ಉದಾಹರಣೆಗೆ.

221
00:13:40,900 --> 00:13:46,920
ಮತ್ತು ಒಂದು ನಿರ್ದಿಷ್ಟ
ಬೆಕ್ಕು ವಸ್ತು ಬೆಕ್ಕು ಇರುತ್ತದೆ

222
00:13:46,920 --> 00:13:50,930
ನಾವು ಸೂಚಿಸಲು ಅಲ್ಲಿ
ಬಣ್ಣ, ವಯಸ್ಸು ಮತ್ತು ತಳಿ.

223
00:13:50,930 --> 00:13:53,790
>> ಆ ಸಂದರ್ಭದಲ್ಲಿ, ನಮ್ಮ ವಸ್ತು
ಇನ್ನು ಮುಂದೆ ಒಂದು ವರ್ಗ ಎಲ್ಲಿಯೂ.

224
00:13:53,790 --> 00:14:00,010
ನಾವು ವರ್ಗ ಟೆಂಪ್ಲೆಟ್ ನಕಲಿಸಿ ಮತ್ತು
ನಾವು ಪ್ರತಿ ನಿರ್ದಿಷ್ಟ ಮಾಹಿತಿ ಸೂಚಿಸಿ

225
00:14:00,010 --> 00:14:04,510
ನಿರ್ದಿಷ್ಟ ವಸ್ತುವಿಗೆ
ಇದು ಸ್ವತಂತ್ರ ಮಾಡಲು.

226
00:14:04,510 --> 00:14:09,350
ಮತ್ತು ನೀವು ಕರೆ ಮಾಡಿದಾಗ
ವಸ್ತುವಿನ ಒಳಗೆ ಒಂದು ವಿಧಾನ,

227
00:14:09,350 --> 00:14:16,640
ನೀವು, ವಸ್ತುವಿನ ಮೇಲೆ ಮಿಯಾಂವ್ ಕರೆ
ಇದು ನೀವು ಕೇವಲ ದಾಖಲಿಸಿದವರು ಬೆಕ್ಕು.

228
00:14:16,640 --> 00:14:19,020
>> ಬಹುಶಃ ನೀವು ಮುದ್ರಿಸುತ್ತದೆ
"ಹಲೋ ವರ್ಲ್ಡ್ ರೀತಿಯ!

229
00:14:19,020 --> 00:14:20,000
ಮಿಯಾಂವ್. "

230
00:14:20,000 --> 00:14:22,110
ಪ್ರೆಟಿ ಮೋಹಕವಾದ.

231
00:14:22,110 --> 00:14:24,500
ಸರಿ, ಅವರ ಕೇವಲ ಅವಕಾಶ
ಕೆಲವು ವಿವರಗಳನ್ನು ಪ್ರವೇಶಿಸಲು

232
00:14:24,500 --> 00:14:30,650
ಮತ್ತು ಖಂಡಿತವಾಗಿಯೂ ಮಾಡುತ್ತದೆ ಎಂಬುದನ್ನು
ಐಒಎಸ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಎಂಬ ಭಾಷಾಂತರಿಸಲು.

233
00:14:30,650 --> 00:14:36,500
ಐಒಎಸ್ ಪ್ರತಿಯೊಂದು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಆದ್ದರಿಂದ ರಲ್ಲಿ
ವರ್ಗ ಎರಡು ಕಡತಗಳನ್ನು ಅಳವಡಿಸಲಾಗಿದೆ.

234
00:14:36,500 --> 00:14:41,420
ಒಂದು ಫೈಲ್, ಇಲ್ಲಿ ಇದು
ಇಂಟರ್ಫೇಸ್ ಕರೆಯಲಾಗುತ್ತದೆ.

235
00:14:41,420 --> 00:14:45,300
ಇನ್ನೊಂದು ಫೈಲ್, ಇಲ್ಲಿ ಇದು
ಅನುಷ್ಠಾನ ಕರೆಯಲಾಗುತ್ತದೆ.

236
00:14:45,300 --> 00:14:48,890
>> ಸಾಮಾನ್ಯವಾಗಿ ಇಂಟರ್ಫೇಸ್
extension.h ಹೊಂದಿರುತ್ತದೆ

237
00:14:48,890 --> 00:14:51,740
ನಾವು ಸಿ ಗ್ರಂಥಾಲಯಗಳು ಕಂಡ.

238
00:14:51,740 --> 00:14:56,340
ಮತ್ತು ಅನುಷ್ಠಾನ ಕಡತವಾಗಿರುತ್ತದೆ
extension.n ಮಾಡಲಿಕ್ಕೆ.

239
00:14:56,340 --> 00:14:57,260
ಇದು ವಿಲಕ್ಷಣ ಭಾಸವಾಗುತ್ತದೆ.

240
00:14:57,260 --> 00:15:01,270
ಆದರೆ ಯಾವುದೇ ಇಲ್ಲ, ಸಿ ವಾಸ್ತವವಾಗಿ ಎನ್ ಅರ್ಥ
ಆ ನಡುವೆ ಮೂಲಭೂತ ವ್ಯತ್ಯಾಸವನ್ನು

241
00:15:01,270 --> 00:15:02,100
ಎರಡು.

242
00:15:02,100 --> 00:15:06,650
ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಇದ್ದೇವೆ ಎಂದು ನೋಡಬಹುದು
ವಸ್ತು: ಇಂಟರ್ಫೇಸ್, ಕ್ಯಾಟ್ ಘೋಷಿಸುವ.

243
00:15:06,650 --> 00:15:10,660

244
00:15:10,660 --> 00:15:13,760
ಎಂದು ಪಿತ್ರಾರ್ಜಿತ ಕರೆಯಲಾಗುತ್ತದೆ.

245
00:15:13,760 --> 00:15:19,170
ನಾವು ಮೂಲತಃ ವಂಶಪಾರಂಪರ್ಯವಾಗಿ ನೀವು
ವಸ್ತು ವರ್ಗ ಬೆಕ್ಕು ವರ್ಗ.

246
00:15:19,170 --> 00:15:24,790
ಆದ್ದರಿಂದ ಪ್ರತಿ ಆಸ್ತಿ ಮತ್ತು ವಿಧಾನ ಎಂದು
ಹಿಂದೆ ವಸ್ತು ವರ್ಗ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ

247
00:15:24,790 --> 00:15:28,560
ಸ್ವಯಂಚಾಲಿತವಾಗಿ ವ್ಯಾಖ್ಯಾನಿಸಲಾಯಿತು
ಬೆಕ್ಕು ವರ್ಗ ಹಾಗೂ.

248
00:15:28,560 --> 00:15:35,900
>> ಅದಕ್ಕೆ ಜೊತೆಯಾಗಿ, ನಾವು ಬಣ್ಣ ವ್ಯಾಖ್ಯಾನಿಸಲು,
ತಳಿ, ಮತ್ತು ವಯಸ್ಸಿನ, ಮೂರು ಅಸ್ಥಿರ.

249
00:15:35,900 --> 00:15:39,360
ವಾಸ್ತವವಾಗಿ ತೋರುತ್ತಿದೆ
ನೀವು ಮೊದಲು ಮಾಡಿದ ವಿಷಯ.

250
00:15:39,360 --> 00:15:41,770
ಇದು struct ಕಾಣುತ್ತದೆ.

251
00:15:41,770 --> 00:15:44,950
ಮೂಲತಃ ವಾಕ್ಯ
struct ಘೋಷಣೆ,

252
00:15:44,950 --> 00:15:47,710
ಮತ್ತು ಸರಿ.

253
00:15:47,710 --> 00:15:51,825
ಮತ್ತು ನಾನು ಮೊದಲೇ ಹೇಳಿದಂತೆ ರಿಂದ
ವ್ಯತ್ಯಾಸ ಒಂದು struct

254
00:15:51,825 --> 00:15:53,960
ಮತ್ತು ವಸ್ತುವಿನ, ಒಂದು
ಮೂಲಭೂತ ವ್ಯತ್ಯಾಸಗಳು

255
00:15:53,960 --> 00:15:59,080
ವಸ್ತುವಿನ ವಿಧಾನವನ್ನು ಹೊಂದಿದೆ
ಆದರೆ ಒಂದು struct ಕೇವಲ ಅಸ್ಥಿರ ಹೊಂದಿದೆ.

256
00:15:59,080 --> 00:16:03,450
ಆದ್ದರಿಂದ ಗುಣಗಳನ್ನು ಜೊತೆಗೆ ಅಥವಾ
ನಾವು ವಸ್ತುವನ್ನು ರಚಿಸಿದ ಚರಾಂಕಗಳ

257
00:16:03,450 --> 00:16:05,700
ನಾವು ಕೆಲವು ವಿಧಾನ ಸೂಚಿಸಲು.

258
00:16:05,700 --> 00:16:09,720
>> ಕೇವಲ ನಾವು ಇಲ್ಲಿ ಹೇಳುತ್ತಾರೆ
ಒಂದು ಮಿಯಾಂವ್ ಎರಡು ವಿಧಾನಗಳು,

259
00:16:09,720 --> 00:16:12,460
ಇನ್ನೊಂದನ್ನು ಚೇಸ್ ಮೌಸ್.

260
00:16:12,460 --> 00:16:18,600
ನಾವು ಬಹುಶಃ ಹಾದುಹೋಗುವ ಬೇಕಿರುವ
ನಮ್ಮ ಹಿಂದಿನ ಆಧಾರದ ಮೇಲೆ ನಿಯತಾಂಕ

261
00:16:18,600 --> 00:16:20,440
ಘೋಷಣೆ ಮಾದರಿಯಲ್ಲಿ.

262
00:16:20,440 --> 00:16:22,160
ನೀವು ಬಹುಶಃ ಒಂದು ಮೌಸ್ ಹಾದುಹೋಗುವ ಬಯಸುತ್ತೇನೆ.

263
00:16:22,160 --> 00:16:25,180
ಮತ್ತು ನೀವು ಬಹುಶಃ ಬಯಸುವಿರಿ
ಒಂದು bool ಸೂಚಿಸುತ್ತದೆ ಮರಳಲು

264
00:16:25,180 --> 00:16:30,010
ನಿಮ್ಮ ಬೆಕ್ಕು ಯಶಸ್ವಿಯಾಗಿ ವೇಳೆ
ಮೌಸ್ ಸೆಳೆಯಿತು ಅಥವಾ.

265
00:16:30,010 --> 00:16:33,170
>> ಈ ಇಂಟರ್ಫೇಸ್, ಆದರೆ ನಾವು
ನೋಡಿ ವಾಸ್ತವವಾಗಿ ಇಂಟರ್ಫೇಸ್

266
00:16:33,170 --> 00:16:35,150
ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ.

267
00:16:35,150 --> 00:16:40,800
ಇದು ಕೇವಲ ಒಂದು ಪ್ರೋಗ್ರಾಂ ಹೇಳುತ್ತದೆ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ ಏನು
ಯಾವ ಬೆಕ್ಕು ವರ್ಗ ಅಸ್ತಿತ್ವದಲ್ಲಿದೆ.

268
00:16:40,800 --> 00:16:43,640
ಆದ್ದರಿಂದ ಸಲುವಾಗಿ
ಪ್ರೋಗ್ರಾಂ ಏನಾದರೂ,

269
00:16:43,640 --> 00:16:46,680
ನಾವು ಜಾರಿ ಕಡತಗಳನ್ನು ಮಾಡಬೇಕು.

270
00:16:46,680 --> 00:16:51,940
ಇಲ್ಲಿ, ನಾವು ಮಾಡಲು ಮೊದಲ ವಿಷಯ
ನಿಸ್ಸಂಶಯವಾಗಿ ನಾವು ಇಂಟರ್ಫೇಸ್ ಆಮದು.

271
00:16:51,940 --> 00:16:56,470
ನಾವು ಇಂಟರ್ಫೇಸ್ ಆಮದು ನಂತರ,
ನಾವು ವಿಧಾನವನ್ನು ವಿವರಿಸಿ.

272
00:16:56,470 --> 00:17:00,150
>> ಸುಮ್ಮನೆ ಇಲ್ಲಿ ಮಿಯಾಂವ್ ಹೇಳುತ್ತಾರೆ
ಕೇವಲ ಮುದ್ರಿಸುತ್ತದೆ ಎಂದು

273
00:17:00,150 --> 00:17:01,740
"ಹಲೋ ವರ್ಲ್ಡ್!" ಕನ್ಸೋಲಿಗೆ.

274
00:17:01,740 --> 00:17:04,319

275
00:17:04,319 --> 00:17:08,460
ಮತ್ತು ಅನುಷ್ಠಾನದ ನಂತರ
ಫೈಲ್, ನಾವು ಬಹುಮಟ್ಟಿಗೆ ಮುಗಿಸಿದ್ದೀರಿ.

276
00:17:08,460 --> 00:17:14,530
ಈ ಮೂಲತಃ ಒಂದು ವರ್ಗ
ಒಂದು ವರ್ಗ ಘೋಷಣೆ.

277
00:17:14,530 --> 00:17:19,970
ಈಗ ಪ್ರಶ್ನೆ ಆಗುತ್ತದೆ
ಹೇಗೆ ನೀವು ಒಂದು ವೇರಿಯೇಬಲ್ ಘೋಷಿಸಲು ಇಲ್ಲ?

278
00:17:19,970 --> 00:17:26,880
ರೀತಿಯಲ್ಲಿ ನೀವು ರಚಿಸಲು ಒಂದು ವರ್ಗ ಬಳಸಲು
ಉದ್ದೇಶ ಸಿ ಆಬ್ಜೆಕ್ಟ್ ಇಲ್ಲಿ ಬರೆಯಲಾಗಿದೆ.

279
00:17:26,880 --> 00:17:30,730
>> ನೀವು ಮೊದಲ ಸೂಚಿಸುವಂತೆ
ಈ, ಒಂದು ಬೆಕ್ಕು ಪಾಯಿಂಟರ್

280
00:17:30,730 --> 00:17:38,700
ಉದ್ದೇಶ ಸಿ ಪ್ರತಿ ವಸ್ತುವಿನ ಕಾರಣ
ಅಂತಿಮವಾಗಿ ಒಂದು ಪಾಯಿಂಟರ್ ಅನುಷ್ಠಾನಗೊಳಿಸಲಾಗುತ್ತದೆ.

281
00:17:38,700 --> 00:17:46,210
ಮತ್ತು ನೀವು ವರ್ಗ ಕರೆ, ಕರೆ
ಮೂಲತಃ, malloc ಇದು alloc, ಎಂದು,

282
00:17:46,210 --> 00:17:51,220
ಕಾರ್ಯವ್ಯವಸ್ಥೆಯನ್ನು ಹೇಳುವ ನೀವು
ಈ ವಸ್ತುವನ್ನು ಕೆಲವು ನೆನಪಿನ ಅಗತ್ಯವಿದೆ.

283
00:17:51,220 --> 00:17:55,780
ನಂತರ ನೀವು ವಸ್ತುವನ್ನು ಹೊಂದಿರುವ
ಈಗಾಗಲೇ ಮತ್ತು ನೀವು ಆರಂಭಿಸಲು.

284
00:17:55,780 --> 00:17:56,780
ಈ ಕೇವಲ ಸಂಪ್ರದಾಯವಾಗಿದೆ.

285
00:17:56,780 --> 00:17:59,390

286
00:17:59,390 --> 00:18:04,410
ನಾನು ಸ್ವಲ್ಪ ವಿಲಕ್ಷಣ ಇದು ಗೊತ್ತಿಲ್ಲ, ಆದರೆ
ಈ ಆಪಲ್ ಸ್ಟಫ್ ವಾಸ್ತವವಾಗಿ ಹೇಗೆ.

287
00:18:04,410 --> 00:18:07,130
>> ಗುಣಲಕ್ಷಣಗಳು ನಿಯೋಜಿಸುವ
ವಾಸ್ತವವಾಗಿ ಬಹಳ ಸರಳ.

288
00:18:07,130 --> 00:18:09,250
ಇದು ಹೋಲುತ್ತದೆ ಇಲ್ಲಿದೆ
ನೀವು ಏನು ಮಾಡುತ್ತಿರುವುದು

289
00:18:09,250 --> 00:18:13,780
ನೀವು ಕೆಲವು ನಿರ್ದಿಷ್ಟ ನಿಯೋಜಿಸುವ ಇರುವ
struct ಒಳಗೆ ಕ್ಷೇತ್ರ.

290
00:18:13,780 --> 00:18:16,830
ನೀವು ವೇರಿಯಬಲ್ ಹೊಂದಿವೆ
, ಆಸ್ತಿ ಹೆಸರು ಹೆಸರು,

291
00:18:16,830 --> 00:18:20,140
ಮತ್ತು ಇದು ಒಂದು ನಿರ್ದಿಷ್ಟ ಮೌಲ್ಯವನ್ನು.

292
00:18:20,140 --> 00:18:24,120
ಮತ್ತು ವಿಧಾನ ಕರೆ ಹೋಲುತ್ತದೆ.

293
00:18:24,120 --> 00:18:29,080
ಕರೆ ವಿಧಾನ
ಮೂಲತಃ ನಾನು ಬಗ್ಗೆ ಮಾತನಾಡಲು ಏನು

294
00:18:29,080 --> 00:18:32,390
ಉದ್ದೇಶ ಸಿ ವಿಧಾನ ಕರೆ

295
00:18:32,390 --> 00:18:36,660
>> ನೀವು, ಒಂದು ವಸ್ತುವಿನ ಹಾದುಹೋಗುವ ನೀವು
ಈ ಸಂದರ್ಭದಲ್ಲಿ ಇದು, myCat ಎಂದು ವಿಶೇಷವೇನು

296
00:18:36,660 --> 00:18:42,490
ಮತ್ತು ನೀವು ಹೆಸರು ವಿಧಾನ ಹಾದುಹೋಗುವ ನೀವು.

297
00:18:42,490 --> 00:18:47,130
ನೀವು ವಸ್ತು ಮಾತನಾಡುವ ನೀವು ವೇಳೆ,
ನೀವು ಮಿಯಾಂವ್ ಎಂದು myCat,.

298
00:18:47,130 --> 00:18:48,570
ಇದು ಬಹಳ ಆಸಕ್ತಿಕರವಾಗಿದೆ.

299
00:18:48,570 --> 00:18:52,010

300
00:18:52,010 --> 00:18:55,680
ನಂತರ, ಒಂದು ಇಲ್ಲ
ಹೆಚ್ಚು ಅಗತ್ಯ ವಿನ್ಯಾಸ ಮಾದರಿ

301
00:18:55,680 --> 00:18:59,940
ನಾವು ಬಗ್ಗೆ ಮಾತನಾಡಲು ಅಗತ್ಯವಿರುವ
ನಿಜವಾದ ಎಸ್ ಕೋಡ್ ಪಡೆಯುವ ಮೊದಲು.

302
00:18:59,940 --> 00:19:03,300
ಆ ವಿನ್ಯಾಸ ಮಾದರಿಯಲ್ಲಿ ಕರೆಯಲಾಗುತ್ತದೆ
ಕ್ರಿಯೆಯನ್ನು ಪ್ರೋಗ್ರಾಮಿಂಗ್ ನಡೆಸುತ್ತಿದೆ.

303
00:19:03,300 --> 00:19:09,660
ಅತಿ ಹೆಚ್ಚು ಬಹುಶಃ ಒಂದಾಗಿದೆ
ಐಒಎಸ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮೂಲಭೂತ ಕಲ್ಪನೆಗಳನ್ನು.

304
00:19:09,660 --> 00:19:14,410
>> ನೀವು ಬಹುಶಃ ನಿಖರವಾಗಿ ಗೊತ್ತಿಲ್ಲ
ಕ್ರಿಯೆಯನ್ನು ಚಾಲಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್, ಆಗಿದೆ

305
00:19:14,410 --> 00:19:16,990
ಆದರೆ ನಿಜವಾಗಿಯೂ ಭಯಾನಕ ಅಲ್ಲ.

306
00:19:16,990 --> 00:19:20,400
ಸರಿ ವಾಸ್ತವವಾಗಿ, ನೀವು
ಈಗಾಗಲೇ ಆ ಸಂದರ್ಭದಲ್ಲಿ ಮಾಡಲಾಗುತ್ತದೆ.

307
00:19:20,400 --> 00:19:24,894
ನೀವು ಬಹುಶಃ ಬಂದಿದೆ ಸಾಲುಗಳನ್ನು ಒಂದಾಗಿದೆ
ಈಗಾಗಲೇ ಕಳೆದ [ಕೇಳಿಸುವುದಿಲ್ಲ] ಬರೆಯಲಾಗಿದೆ

308
00:19:24,894 --> 00:19:26,810
CS50 ಆಫ್,
google.maps.event.addListener (ಮಾರ್ಕರ್,

309
00:19:26,810 --> 00:19:27,810
)} {), ಕಾರ್ಯ ("ಕ್ಲಿಕ್" :.

310
00:19:27,810 --> 00:19:32,410

311
00:19:32,410 --> 00:19:37,620
ನೀವು ಈ ಲೈನ್ ಕರೆದು
ಮೂಲಭೂತವಾಗಿ ಕಂಪ್ಯೂಟರ್ ಹೇಳುವ

312
00:19:37,620 --> 00:19:42,650
ಘಟನೆಯನ್ನು ಆದಾಗ
, ಮಾರ್ಕರ್ ನಡೆಯುತ್ತದೆ "ಕ್ಲಿಕ್"

313
00:19:42,650 --> 00:19:43,630
ಆ ಕಾರ್ಯವನ್ನು ಬಳಸಲು.

314
00:19:43,630 --> 00:19:46,910

315
00:19:46,910 --> 00:19:50,950
>> ಈ ಅತ್ಯಂತ ವಿಭಿನ್ನವಾಗಿದೆ
ನೀವು mario.c ಏನು.

316
00:19:50,950 --> 00:19:56,670
Mario.c ನೀವು ಕೇವಲ ಪ್ರೋಗ್ರಾಂ
ಒಮ್ಮೆ, ನೀವು ಕೊಡುವ ಉತ್ಪಾದನೆಯು,

317
00:19:56,670 --> 00:19:58,590
ಮತ್ತು ನೀವು ಮುಗಿಸಿದ್ದೀರಿ.

318
00:19:58,590 --> 00:20:02,590
ಈ ರೀತಿಯ ಹಾಗೆ
ಒಂದು ಶಾಟ್ ಕಾರ್ಯಕ್ರಮಗಳು.

319
00:20:02,590 --> 00:20:05,830
ಕ್ರಿಯೆಯನ್ನು ಚಾಲಿತ ಕಾರ್ಯಕ್ರಮಗಳು
ತುಂಬಾ ಭಿನ್ನವಾಗಿರುತ್ತವೆ.

320
00:20:05,830 --> 00:20:10,230
ಫೇಸ್ಬುಕ್ ಒಂದು ವೇಳೆ, ಅವರ ಊಹಿಸಿ ಲೆಟ್
ಶಾಟ್ ಪ್ರೋಗ್ರಾಂ ಇದು ಒಳ್ಳೆಯ ಅಲ್ಲ.

321
00:20:10,230 --> 00:20:13,750
ನೀವು ಫೇಸ್ಬುಕ್ ಹೋಗಿ
ಒಮ್ಮೆ ಮತ್ತು ಇದನ್ನು.

322
00:20:13,750 --> 00:20:16,700
ನೀವು ಕೆಲವು ಔಟ್ಪುಟ್ ನೀಡುತ್ತದೆ
ಮತ್ತು ನೀವು ಹಿಂದಕ್ಕೆ ಸಿಗಲಿಲ್ಲ.

323
00:20:16,700 --> 00:20:19,380
ನೀವು ಹೆಚ್ಚು ಏನು ದೊರಕಲಿಲ್ಲ.

324
00:20:19,380 --> 00:20:23,880
>> ಇಲ್ಲಿ ವಿಶೇಷವಾಗಿ
ನಾವು ಬಳಸಲು ಮಾದರಿ

325
00:20:23,880 --> 00:20:26,940
ಕ್ರಿಯೆಯನ್ನು ಆದ್ದರಿಂದ, ಚಾಲಿತ
ಪ್ರತಿ ಕಾರ್ಯ ತಿನ್ನುವೆ

326
00:20:26,940 --> 00:20:31,480
ಆಧರಿಸಿ ಕ್ಯಾಚ್ ಏನು
ಈವೆಂಟ್ ಸಂಭವಿಸಲಿಲ್ಲ.

327
00:20:31,480 --> 00:20:34,670
ಉದಾಹರಣೆಗೆ, ನಾವು ಹೊಂದಿದ್ದರೆ
ಒಂದು ಬಟನ್ ಮತ್ತು ನಾವು ಸೂಚಿಸಲು

328
00:20:34,670 --> 00:20:39,870
ಆ ಬಟನ್ ಕ್ಲಿಕ್ ಬಂದ ಆ,
ಎಂಬ ಕಾರ್ಯ ಕರೆ "ಹಲೋ ವರ್ಲ್ಡ್!"

329
00:20:39,870 --> 00:20:47,810
ಆ ರೀತಿಯಲ್ಲಿ ನಾವು ಮಾಡಬಹುದು
ಕಾರ್ಯ ತರ್ಕ ನಿರ್ವಹಿಸಲು

330
00:20:47,810 --> 00:20:50,560
ಹೆಚ್ಚು ಹೊಂದಿಕೊಳ್ಳುವ ರೀತಿಯಲ್ಲಿ ಹರಿಯುತ್ತವೆ.

331
00:20:50,560 --> 00:20:55,840
ಬಳಕೆದಾರ ಮಾಡಲು ಅಥವಾ ಒಂದು ಫಂಕ್ಷನ್ ಕರೆಯಬಹುದು
ಎಂದು ಈಗಾಗಲೇ ಕರೆಯಲ್ಪಟ್ಟಿದೆ.

332
00:20:55,840 --> 00:20:59,900
ಇದು ಸಂಪೂರ್ಣವಾಗಿ ಬಳಕೆದಾರರು ಏನು ಆಧರಿಸಿ.

333
00:20:59,900 --> 00:21:04,080
>> ಆದ್ದರಿಂದ ನಾವು ಈ ಎಂದು ನೋಡಬಹುದು
mario.c ವಾಸ್ತವವಾಗಿ ಉತ್ತಮ.

334
00:21:04,080 --> 00:21:07,190
ಮತ್ತು ಒಳ್ಳೆಯ ಸುದ್ದಿ ಇದು ಎಂಬುದು
ವಾಸ್ತವವಾಗಿ ಒಂದು ಹೊಸ ಪರಿಕಲ್ಪನೆ.

335
00:21:07,190 --> 00:21:12,140
ನೀವು ಹುಡುಗರಿಗೆ ಈಗಾಗಲೇ ಮಾಡಿದ
ಕೊನೆಯ ಸಮಸ್ಯೆ ಸೆಟ್.

336
00:21:12,140 --> 00:21:16,640
ಉದ್ದೇಶ ಸಿ ಇವೆ
ಮೂರು ವಿವಿಧ ಚಿತ್ರಗಳು

337
00:21:16,640 --> 00:21:19,030
ಕ್ರಿಯೆಯನ್ನು ಚಾಲಿತ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಫಾರ್.

338
00:21:19,030 --> 00:21:21,970
ಮೊದಲ ರೇಖಾಚಿತ್ರ
ಗುರಿ ಕ್ರಮ ಎಂದು,

339
00:21:21,970 --> 00:21:26,990
ಅಲ್ಲಿ ನೀವು ಒಂದು ಬಟನ್ ಬೈಂಡ್
ಕೆಲವು ಕಾರ್ಯದಲ್ಲಿ ಪತ್ರಿಕಾ.

340
00:21:26,990 --> 00:21:31,590
ನೀವು ಕ್ಲಿಕ್ ಬಂದ ಕೇವಲ, ಹೇಳುತ್ತಾರೆ
ಕೆಲವು ಬಟನ್, ನೀವು ಕೆಲವು ಕಾರ್ಯ ಕರೆ.

341
00:21:31,590 --> 00:21:33,620
ಈ ಸರಳ ಗುರಿ ಕಾರ್ಯವಾಗಿದೆ.

342
00:21:33,620 --> 00:21:35,580
>> ಎರಡನೇ ಒಂದಾಗಿದೆ
ವಾಸ್ತವವಾಗಿ ಕಠಿಣ ಒಂದು,

343
00:21:35,580 --> 00:21:38,450
ಇದು ಪ್ರೊಟೋಕಾಲ್ ನಿಯೋಗ ಕರೆಯಲಾಗುತ್ತದೆ.

344
00:21:38,450 --> 00:21:41,800
ನಾವು ವಿವರಿಸಲು ನೀನು
ಮಹಾನ್ ವಿವರ ನಂತರ.

345
00:21:41,800 --> 00:21:44,420
ಮತ್ತು ಮೂರನೇ ರೀತಿಯಲ್ಲಿ ಅಧಿಸೂಚನೆ ಆಗಿದೆ.

346
00:21:44,420 --> 00:21:46,770
ಈ ವಾಸ್ತವವಾಗಿ ಅಲ್ಲ
ಬಹಳ ಮುಖ್ಯ ದೂರದ

347
00:21:46,770 --> 00:21:50,920
ನಾವು ಕಾಳಜಿ ಮಾಡಿದಾಗ, ಅವಕಾಶ ಏಕೆಂದರೆ
ನೀವು ಅಧಿಸೂಚನೆ ಬಳಸಲು ನೀನು

348
00:21:50,920 --> 00:21:53,310
ನಿಮ್ಮ ಅಂತಿಮ ಯೋಜನೆಯಲ್ಲಿ ಬಹಳ ಕಡಿಮೆ.

349
00:21:53,310 --> 00:21:56,440
ಆದ್ದರಿಂದ ನಾವು ಭಾಗವನ್ನು ಬಿಡಲು ನೀನು.

350
00:21:56,440 --> 00:21:59,460
>> ಮತ್ತು ನಾವು ಧುಮುಕುವುದಿಲ್ಲ ನೀನು
ಪ್ರೊಟೋಕಾಲ್ ನಿಯೋಗ ಆಗಿ.

351
00:21:59,460 --> 00:22:02,380

352
00:22:02,380 --> 00:22:04,470
ಇಷ್ಟಕ್ಕೂ ಒಂದು ಪ್ರೋಟೋಕಾಲ್ ಏನು?

353
00:22:04,470 --> 00:22:06,450
ಅಥವಾ ನಿಯೋಗ ನಿಖರವಾಗಿ ಏನು?

354
00:22:06,450 --> 00:22:09,670
ನ ಪ್ರಾರಂಭಿಸಲು ಪ್ರೋಟೋಕಾಲ್ ಬಗ್ಗೆ ಮಾತನಾಡೋಣ.

355
00:22:09,670 --> 00:22:13,360
ಪ್ರೋಟೋಕಾಲ್ಗಳು ಘಟನೆಗಳು ಆದರೆ ಏನೂ.

356
00:22:13,360 --> 00:22:19,230
ಆದರೆ ಈ ಘಟನೆಗಳು ನೀಡಲಾಗುತ್ತದೆ
ಆಪಲ್ ನೀವು ಆರಂಭಿಸಲು.

357
00:22:19,230 --> 00:22:22,640
ಉದಾಹರಣೆಗೆ, ನಾನು ಮನುಷ್ಯ
ನೀವು ಎಷ್ಟು ಸಂಪೂರ್ಣವಾಗಿ ಖಚಿತವಾಗಿ

358
00:22:22,640 --> 00:22:27,930
ಹುಡುಗರಿಗೆ ಆಪಲ್ನ ಮೂಲ ಬಳಸಲು
ಅಪ್ಲಿಕೇಶನ್ ಮೇಲ್ ಅಥವಾ ಸಂಪರ್ಕ,

359
00:22:27,930 --> 00:22:32,180
ಆದರೆ ಪ್ರತಿ ಬಾರಿ ನೀವು ಸ್ಕ್ರಾಲ್
ಟೇಬಲ್ ಮತ್ತು ಸೆಲ್ ಒತ್ತಿ

360
00:22:32,180 --> 00:22:36,130
ಮೇಜಿನ ಮೇಲೆ, ಒಂದು ಘಟನೆಯಾಗಿದೆ.

361
00:22:36,130 --> 00:22:38,330
>> ಮತ್ತು ನೀವು ಮಾಡಲು ಬಯಸಿದರೆ
ನಿಮ್ಮ ಮೂಲಕ ಆ ಸಂದರ್ಭದಲ್ಲಿ,

362
00:22:38,330 --> 00:22:40,410
ಇದು ವಾಸ್ತವವಾಗಿ ಸ್ವಲ್ಪ ಕಷ್ಟ.

363
00:22:40,410 --> 00:22:44,880
ಆದ್ದರಿಂದ ಆಪಲ್ ಸಹ ನೀವು ಕೊಟ್ಟ
ನೀವು ನೇರವಾಗಿ ಬಳಸಬಹುದಾದ ಆದ್ದರಿಂದ

364
00:22:44,880 --> 00:22:49,610
ಕ್ರಿಯೆಯನ್ನು ನೀವೇ ಏನಾದರೂ.

365
00:22:49,610 --> 00:22:52,980
ಪ್ರೋಟೋಕಾಲ್ಗಳು ವಾಸ್ತವವಾಗಿ
ನಿಜವಾಗಿಯೂ ವ್ಯಾಪಕವಾಗಿ ಬಳಸಲಾಗುತ್ತದೆ

366
00:22:52,980 --> 00:22:58,320
ಉದ್ದೇಶ ಸಿ ವೆಲ್ ನಲ್ಲಿ
ವಾಸ್ತವವಾಗಿ, ಪ್ರತಿಯೊಂದು ಅಪ್ಲಿಕೇಶನ್

367
00:22:58,320 --> 00:23:00,870
ಏನೋ ಸೆಳೆಯಿತು ಅಪ್ಲಿಕೇಶನ್ ಪ್ರತಿನಿಧಿ ಹೊಂದಿದೆ.

368
00:23:00,870 --> 00:23:06,330
ಸೂಕ್ಷ್ಮ ಒಳಗೆ ಎಲ್ಲಾ ಆಗಿದೆ
ಅಪ್ಲಿಕೇಶನ್ ಲೋಡ್ ಪ್ರೋಟೋಕಾಲ್ಗಳು.

369
00:23:06,330 --> 00:23:12,470
>> ಕೇವಲ ಇಲ್ಲ ಹೇಳುತ್ತಾರೆ
ಅಪ್ಲಿಕೇಶನ್ ಕ್ರಿಯೆಯನ್ನು ಲೋಡ್ ಮಾಡಿದರು.

370
00:23:12,470 --> 00:23:18,200
ನೀವು ಮಾಡಿದ ನಂತರ ಏನಾಗಬೇಕು
ಒಂದು ಅಪ್ಲಿಕೇಶನ್, ನೀವು ಅಪ್ಲಿಕೇಶನ್ ತೆರೆಯಲು ನಂತರ,

371
00:23:18,200 --> 00:23:22,630
ನಂತರ ನೀವು ನಂತರ ಅಪ್ಲಿಕೇಶನ್ ಮುಚ್ಚಿ, ಅಥವಾ
ನೀವು ನಿದ್ರೆ ಐಫೋನ್ ಪುಟ್.

372
00:23:22,630 --> 00:23:27,480
ಈ ಹೊಂದಿರುವ ಎಲ್ಲಾ ಘಟನೆಗಳು
ಈಗಾಗಲೇ ನೀವು ನೀಡಲಾಗಿದೆ.

373
00:23:27,480 --> 00:23:34,730
ಮತ್ತು ಮೂಲತಃ ಈ ಕಣಗಳು ಒಳಗೆ
ಯಾವುದೇ ಅನುಷ್ಠಾನ ಇರುತ್ತದೆ.

374
00:23:34,730 --> 00:23:39,750
ಆಪಲ್ ಈ ಕಾರ್ಯವನ್ನು ಎಂದು ಹೇಳಿದರು
ಕೆಲವು ಘಟನೆ ಸಂಭವಿಸಿದರೂ ಏನಾಗುವುದು,

375
00:23:39,750 --> 00:23:44,380
ಆದರೆ ನೀವು ಏನು
ಕಾರ್ಯ ಸಂಪೂರ್ಣವಾಗಿ ಅಪ್ ನಿಮಗೆ ಆಗಿದೆ.

376
00:23:44,380 --> 00:23:49,290
>> ನಿಯೋಗ ಮೂಲತಃ
ವರ್ಗ ಹೇಳುವ

377
00:23:49,290 --> 00:23:53,060
ನೀವು ಈ ನಿಯಮಾವಳಿಗಳು ನಿಭಾಯಿಸುವಂತೆ.

378
00:23:53,060 --> 00:23:55,340
ಇದು ಸ್ವಲ್ಪ ಇಲ್ಲಿದೆ
ಗೊಂದಲ, ಆದರೆ ಇದು

379
00:23:55,340 --> 00:23:59,380
ನಾವು ಮಾಡಿದಾಗ ಹೆಚ್ಚು ಸ್ಪಷ್ಟವಾಗಿರುತ್ತದೆ
ಕ್ರಿಯೆಯನ್ನು ರು ಸಂಕೇತಗಳು.

380
00:23:59,380 --> 00:24:04,760
ಪ್ರೊಟೋಕಾಲ್ ನಿಯೋಗ ವಾಸ್ತವವಾಗಿ ಆಗಿದೆ
ಅರ್ಥದಲ್ಲಿ ಹೆಚ್ಚು ದೃಢವಾದ ಯಾಂತ್ರಿಕ

381
00:24:04,760 --> 00:24:08,160
ನಾವು ನಿಯೋಗ ಹೋದರೆ
ಒಂದು ನಿರ್ದಿಷ್ಟ ವರ್ಗ,

382
00:24:08,160 --> 00:24:12,400
ನಾವು ಮೂಲಭೂತವಾಗಿ ನಿಭಾಯಿಸಬಲ್ಲದು
ಘಟನೆಗಳು ಎಲ್ಲಾ ರೀತಿಯ

383
00:24:12,400 --> 00:24:17,040
ನಾವು ಯಾವುದೇ ವರ್ಗ ಬಳಸಿ,
ತುಂಬಾ ಅನುಕೂಲಕರ ಸಾಧನ.

384
00:24:17,040 --> 00:24:21,530
>> ಆದ್ದರಿಂದ ಒಂದು ತ್ವರಿತ ಉದಾಹರಣೆಗೆ
ಪ್ರೊಟೋಕಾಲ್ ನಿಯೋಗ

385
00:24:21,530 --> 00:24:24,120
ನಾನು ಕುರಿತು ಏನು ಇರುತ್ತದೆ.

386
00:24:24,120 --> 00:24:26,720

387
00:24:26,720 --> 00:24:30,890
ಈ ಪ್ರೋಟೋಕಾಲ್ ನಿರ್ದಿಷ್ಟವಾಗಿ,
tableview [ಕೇಳಿಸುವುದಿಲ್ಲ] ಪಾತ್ರವನ್ನು ಆಯ್ಕೆ

388
00:24:30,890 --> 00:24:35,480
[ನಲ್ಲಿ? ಸೂಚ್ಯಂಕ?] [? ಕಳೆದ. ?] ಆದ್ದರಿಂದ ಈ ಒಂದು
ಕ್ಯಾಚ್ ಎಂದು ಆ ಸಂದರ್ಭದಲ್ಲಿ ನೀವು

389
00:24:35,480 --> 00:24:39,710
ವಾಸ್ತವವಾಗಿ ಒಂದು ನಿರ್ದಿಷ್ಟ ಸ್ಪರ್ಶಿಸಿ
ನಿಮ್ಮ tableview, ಜೀವಕೋಶದ

390
00:24:39,710 --> 00:24:43,570
ಕೇವಲ ನಿಮ್ಮ ಮೇಲ್ ಹೇಳಿ
ಅಥವಾ ನಿಮ್ಮ ಸಂಪರ್ಕಗಳನ್ನು ಅಪ್ಲಿಕೇಶನ್ನಲ್ಲಿ.

391
00:24:43,570 --> 00:24:48,180
>> ಒಂದು ಕಾರ್ಯ ಒಳಗೆ ಇತ್ತು
ಮೂಲತಃ ಏನೂ ಮಾಡುವ.

392
00:24:48,180 --> 00:24:51,950
ಕಾರ್ಯ ಮಾಡುವುದಿಲ್ಲ
ಪೂರ್ವನಿಯೋಜಿತವಾಗಿ ಏನು.

393
00:24:51,950 --> 00:24:55,540
ಆದರೆ ನೀವು ಸೂಚಿಸಬಹುದು
ಕಾರ್ಯ ಮಾಡುತ್ತಾರೆ,

394
00:24:55,540 --> 00:24:59,610
ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಹೊರಗೆ ಯಾವ ನೀಡಿದ.

395
00:24:59,610 --> 00:25:01,610
ತುಂಬಾ ಅನುಕೂಲಕರ ಸಾಧನ.

396
00:25:01,610 --> 00:25:06,840
ಮತ್ತು ಎಲ್ಲಾ ಆ
, ನಾನು ಮೂಲತಃ ನಡೀತಾ

397
00:25:06,840 --> 00:25:11,430
ಕೆಲವು ಅತ್ಯಂತ ಮೂಲಭೂತ ವಾಕ್ಯ ರಕ್ಷಣೆ ಮತ್ತು
ಉದ್ದೇಶ ಸಿ ಮೂಲಭೂತ ಪರಿಕಲ್ಪನೆ

398
00:25:11,430 --> 00:25:15,860
ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಮತ್ತು ನಾವು ಕೆಲವು ರು ಕೋಡ್ ಮಾಡಬಹುದು.

399
00:25:15,860 --> 00:25:17,980
ಹೆಚ್ಚು ಉತ್ತೇಜಕ.

400
00:25:17,980 --> 00:25:21,070
ಆದ್ದರಿಂದ ರು ಕೋಡ್ ವಾಸ್ತವವಾಗಿ ಆಗಿದೆ
ಸ್ವಲ್ಪ ಅಗಾಧ

401
00:25:21,070 --> 00:25:23,330
ನೀವು ಮೊದಲ ಬಾರಿಗೆ ತೆರೆದಾಗ.

402
00:25:23,330 --> 00:25:26,640
>> ಒಂದು ತ್ವರಿತ ಟಿಪ್ಪಣಿ, ಆದ್ದರಿಂದ ನೀವು ವೇಳೆ
ಐಒಎಸ್ ಅಭಿವೃದ್ಧಿ ಮಾಡಲು ಬಯಸುವ,

403
00:25:26,640 --> 00:25:29,630
ನಾನು ಹೆಚ್ಚು ನೀವು ಒಂದು ಮ್ಯಾಕ್ ಶಿಫಾರಸು.

404
00:25:29,630 --> 00:25:33,930
ಐಒಎಸ್ ಅಭಿವೃದ್ಧಿ ಮಾಡುವ ಕಾರಣ
ವಿಂಡೋಸ್ ಕಷ್ಟಕರವಾಗಿತ್ತು, ನಿಜವಾಗಿಯೂ.

405
00:25:33,930 --> 00:25:37,560
Doable ಇಲ್ಲಿದೆ, ಆದರೆ ಇದು ತುಂಬಾ ಕಷ್ಟ.

406
00:25:37,560 --> 00:25:40,610
ಮತ್ತು ನೀವು ಖಂಡಿತವಾಗಿಯೂ ಹಾಗೆ
ಗ್ರಾಂ ಬದಲಾಯಿಸಿ ಬಳಸಲು ಬಯಸುವ.

407
00:25:40,610 --> 00:25:47,950
ಆದ್ದರಿಂದ ರು ಕೋಡ್ ಹೊಂದಿರುತ್ತವೆ
ಅನೇಕ ಪ್ರದೇಶಗಳಲ್ಲಿ.

408
00:25:47,950 --> 00:25:53,050
ನೀವು ಮೊದಲ ರು ತೆರೆದಾಗ ಕೋಡ್
ನೀವು ಸಂಚರಣೆ ಪ್ರದೇಶದಲ್ಲಿ ನೋಡುತ್ತಾರೆ,

409
00:25:53,050 --> 00:25:57,470
ಇದು ಮೂಲತಃ ನೀವು ಎಲ್ಲಾ ತೋರಿಸುತ್ತದೆ
ನಿಮ್ಮ ಪ್ರಸ್ತುತ ಪ್ರಾಜೆಕ್ಟ್ನಲ್ಲಿ ಎಂದು ಕಡತಗಳನ್ನು.

410
00:25:57,470 --> 00:26:03,590
>> ನೀವು ಪಟ್ಟಿ ಪ್ರದೇಶದಲ್ಲಿ, ಹೊಂದಿರುವ
ಮೂಲತಃ ವೀಕ್ಷಣೆಗಳು ನಿರ್ವಹಿಸುವ,

411
00:26:03,590 --> 00:26:08,570
ಅಥವಾ ಕೆಲವು ಸ್ವಲ್ಪ ತ್ವರಿತ
ರು ಕೋಡ್ ಸ್ವತಃ ಬಗ್ಗೆ ಉಪಕರಣಗಳು.

412
00:26:08,570 --> 00:26:11,140
ಮತ್ತು ಈ ನಿಜವಾದ ಸಂಪಾದಕ ಪ್ರದೇಶವಾಗಿದೆ.

413
00:26:11,140 --> 00:26:15,900
ಈ ಪ್ರದೇಶದಲ್ಲಿ ಹೋಲುತ್ತದೆ ಗ್ರಾಂ ಬದಲಾಯಿಸಿ ಆಗಿದೆ,
ಗ್ರಾಂ ಬದಲಾಯಿಸಿ ಹೆಚ್ಚು ಆದರೆ ಉತ್ತಮ.

414
00:26:15,900 --> 00:26:21,150
ಮತ್ತು ಈ ಹಕ್ಕನ್ನು ಪ್ರದೇಶದಲ್ಲಿ, ಆಗಿದೆ
ಉಪಯುಕ್ತತೆಯನ್ನು ಪ್ರದೇಶ ಎಂದು.

415
00:26:21,150 --> 00:26:27,170
ಪ್ರದೇಶದಲ್ಲಿ ನಿಜವಾಗಿಯೂ HANDY ಆಗುತ್ತದೆ
ನೀವು ಇಂಟರ್ಫೇಸ್ ಸೃಷ್ಟಿಸುವುದನ್ನು ಸೂಚಿಸುವ ನೀವು

416
00:26:27,170 --> 00:26:30,070
ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕೆಲವು ತ್ವರಿತ ಸೆಟ್ಅಪ್.

417
00:26:30,070 --> 00:26:34,570
>> ಮತ್ತು ಅಂತಿಮ ಪ್ರದೇಶದಲ್ಲಿ ಡೀಬಗ್ ಆಗಿದೆ.

418
00:26:34,570 --> 00:26:37,970
ಈ ಪ್ರದೇಶದಲ್ಲಿ ಕನ್ಸೋಲ್ ಹೊಂದಿದೆ.

419
00:26:37,970 --> 00:26:43,170
ಆದ್ದರಿಂದ ನೀವು printf ಹೇಳಲು ಬಂದ,
ಅಥವಾ, ನಮ್ಮ ಸಂದರ್ಭದಲ್ಲಿ nslog

420
00:26:43,170 --> 00:26:47,330
ಎಲ್ಲಾ ನಿಮ್ಮ ಫಲಿತಾಂಶಗಳು
ಹೋಗುವ ಇಲ್ಲಿ ಮುದ್ರಿತವಾಗಬಹುದು.

421
00:26:47,330 --> 00:26:48,260
ಸರಿ?

422
00:26:48,260 --> 00:26:52,090
ನಾವು ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ಮಾಡಬಹುದು ಊಹೆ
ಐಒಎಸ್ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು ಉದಾಹರಣೆ.

423
00:26:52,090 --> 00:26:54,220
ಮತ್ತು ಅವರ ವಾಸ್ತವವಾಗಿ ಅಪ್ ರು ಕೋಡ್ ತೆರೆಯಲು ಅವಕಾಶ.

424
00:26:54,220 --> 00:26:57,210

425
00:26:57,210 --> 00:27:01,346
ಆದ್ದರಿಂದ ನೀವು ರು ಕೋಡ್ ತೆರೆಯಲು ಪ್ರತಿ ಬಾರಿ, ಇದು ಇಲ್ಲಿದೆ
ಆ ರೀತಿಯ ತೋರಿಸಲು ಹೋಗಿ.

426
00:27:01,346 --> 00:27:03,220
ನೀವು ಕೇಳಲು ವಿಶೇಷವೇನು
ನೀವು ಏನು ಬಯಸುತ್ತೀರಿ?

427
00:27:03,220 --> 00:27:06,830
ನೀವು ಏನಾದರೂ ಆರಂಭಿಸಲು ಬಯಸುವಿರಾ
ಮೂಲತಃ ಯಾದೃಚ್ಛಿಕ, ಒಂದು ಆಟದ, ನೀವು

428
00:27:06,830 --> 00:27:11,250
ಕೇವಲ ಇಲ್ಲದೆ ಕೋಡ್ ಪರೀಕ್ಷಿಸಬಹುದು
ವಾಸ್ತವವಾಗಿ ಯಾವುದೇ ಅಪ್ಲಿಕೇಶನ್ ಒಪ್ಪಿಸುವ.

429
00:27:11,250 --> 00:27:13,020
>> ನೀವು ಒಂದು ಹೊಸ ಯೋಜನೆಯನ್ನು ರಚಿಸಲು ಬಯಸುತ್ತೀರಿ?

430
00:27:13,020 --> 00:27:16,660
ಅಥವಾ ನೀವು ಮುಂದುವರಿಸಲು ಬಯಸುತ್ತೀರಾ
ಅಸ್ತಿತ್ವದಲ್ಲಿರುವ ಯೋಜನೆಯಲ್ಲಿ ಕೆಲಸ?

431
00:27:16,660 --> 00:27:20,270
ನಮ್ಮ ವಿಷಯದಲ್ಲಿ, ನೀನು
ಒಂದು ಹೊಸ ಯೋಜನೆಯನ್ನು ರಚಿಸಲು.

432
00:27:20,270 --> 00:27:22,980
ಆದ್ದರಿಂದ, ನಿಜವಾಗಿಯೂ ಉತ್ತಮ ಇಲ್ಲಿದೆ
ಕೋಡ್ ವಾಸ್ತವವಾಗಿ ಈಗಾಗಲೇ ಹೊಂದಿದೆ

433
00:27:22,980 --> 00:27:26,820
ಕೆಲವು ಟೆಂಪ್ಲೆಟ್ಗಳನ್ನು ನೀವು ನೀಡಿದ
ವಸ್ತುಗಳು ರಚಿಸಲು.

434
00:27:26,820 --> 00:27:32,680
ನೀವು ಆಟದ ಮಾಡಲು ಬಯಸಿದರೆ, ಕೋಡ್ ರು
ವಾಸ್ತವವಾಗಿ ನೀವು ಒಂದು ಆಟದ ಟೆಂಪ್ಲೇಟ್,

435
00:27:32,680 --> 00:27:36,890
, ಪುಟ ಆಧರಿತ ಅನ್ವಯಗಳ ಹೊಂದಿದೆ
ಟ್ಯಾಬ್ ಆಧಾರಿತ ಅಪ್ಲಿಕೇಶನ್.

436
00:27:36,890 --> 00:27:39,280
ಈ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ನೀನು
ಸರಳ ಏನಾದರೂ,

437
00:27:39,280 --> 00:27:43,230
ಮತ್ತು ನಾವು ಒಂದು ಬಳಸಲು ನೀನು
ಏಕ ನೋಟ ಅಪ್ಲಿಕೇಶನ್.

438
00:27:43,230 --> 00:27:48,270
>> ನಂತರ ಕೇವಲ ನೀವು ಕರೆ ಯಾವ
ನಿಮ್ಮ ಉತ್ಪನ್ನ, ಮತ್ತು, ನಿಮ್ಮ ಹೆಸರೇನು

439
00:27:48,270 --> 00:27:52,760
ನಿಮ್ಮ ಗುರುತು, ಮತ್ತು
ನೀವು ಯಾವ ಭಾಷೆ ಬಳಸುವುದು.

440
00:27:52,760 --> 00:27:57,060
ಇಲ್ಲಿ ನಾವು ಬಯಸುವುದಿಲ್ಲ
ಕೋರ್ ಡೇಟಾ ಬಳಸಿ ಪರಿಶೀಲಿಸಿ.

441
00:27:57,060 --> 00:28:00,170
ಕೋರ್ ಡೇಟಾ ಮೂಲತಃ ಒಂದು databasing ಐಒಎಸ್ ಆಗಿದೆ.

442
00:28:00,170 --> 00:28:05,360
ನೀವು ಕೋರ್ ಡೇಟಾ ಮಾಡಿದರೆ, ರು
ಕೋಡ್ ವ್ಯಾಖ್ಯಾನಿಸಲು ಹೋಗುತ್ತದೆ

443
00:28:05,360 --> 00:28:07,710
ನೀವು ಬಹಳಷ್ಟು ಸಂಕೀರ್ಣವಾದ ತರಗತಿಗಳು.

444
00:28:07,710 --> 00:28:12,740
ನಾವು ಆರ್, ಸರಳ ಎಲ್ಲವೂ ಇರಿಸಿಕೊಳ್ಳಲು
ಕೇವಲ ಕೋರ್ ಡೇಟಾ ಇಲ್ಲದೆ ಮಾಡಲು ಹೋಗಿ

445
00:28:12,740 --> 00:28:15,290
ಇದೀಗ.

446
00:28:15,290 --> 00:28:18,030
>> ನಾವು ಎಂದು ನೀನು ಸಮಸ್ಯೆ
ಬಳಸಿಕೊಂಡು ಸಮಸ್ಯೆಯನ್ನು ಆ ಆಗಿದೆ

447
00:28:18,030 --> 00:28:23,770
ನಾವು ರಚಿಸಲು ಮಾಡಲು ನೀನು ನಾವು
ಮೂಲತಃ C ದಿಂದ ಮಾರಿಯೋ ಆಮದು ಬಯಸುವ

448
00:28:23,770 --> 00:28:25,437
ಐಒಎಸ್ ಅಪ್ಲಿಕೇಶನ್ ಗೆ.

449
00:28:25,437 --> 00:28:26,645
ಆದ್ದರಿಂದ ಮಾರಿಯೋ-ಐಒಎಸ್ ಎಂದು ಕರೆಯೋಣ.

450
00:28:26,645 --> 00:28:31,230

451
00:28:31,230 --> 00:28:34,880
ಸಹಜವಾಗಿ ನೀವು ಎಂಬುದನ್ನು ಸೂಚಿಸಲು
ನಿಮ್ಮ ಯೋಜನೆಯಲ್ಲಿ ಹಾಕಲು ಬಯಸುವ.

452
00:28:34,880 --> 00:28:37,870
ಹಾಗೂ ನಾವು ಹೋಗಿ.

453
00:28:37,870 --> 00:28:41,390
>> ಆದ್ದರಿಂದ ಈ ಒಂದು ಸ್ವಲ್ಪ
ಅಗಾಧ, ಆದರೆ ಈ ವಾಸ್ತವವಾಗಿ

454
00:28:41,390 --> 00:28:43,540
ನಾವು ಕೇವಲ ಸ್ಲೈಡ್ಗಳು ನೋಡಿದ.

455
00:28:43,540 --> 00:28:49,710
ಮತ್ತು ಮೊದಲ ಪ್ರದೇಶದಲ್ಲಿ ನಾವು ಈಗ ನೋಡಿ
ಮೂಲತಃ ಯೋಜನೆಯ ಸಂರಚನಾ ಆಗಿದೆ.

456
00:28:49,710 --> 00:28:53,390
ಆದ್ದರಿಂದ ಎಲ್ಲವನ್ನೂ ನೀವು ಬಯಸುವ
ಯೋಜನೆಯ, ಸಾಧನದ ಯಾವ ರೀತಿಯ,

457
00:28:53,390 --> 00:28:58,810
ಹೇಳಲು ನಾವು ಸಾಧನದ ಯಾವ ರೀತಿಯ
ನಿಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಕಾಣಿಸಿಕೊಳ್ಳುತ್ತವೆ ಬಯಸುತ್ತೀರಿ?

458
00:28:58,810 --> 00:29:01,280
ಇದು ಐಫೋನ್, ಐಪ್ಯಾಡ್ ಅಥವಾ ಸಾರ್ವತ್ರಿಕ?

459
00:29:01,280 --> 00:29:04,660
ಸಾಧನ ದೃಷ್ಟಿಕೋನ, ಈ ವಿಷಯವನ್ನು ಆದ್ದರಿಂದ.

460
00:29:04,660 --> 00:29:08,490
ಅತಿ ಪ್ರಮುಖ,
ಆದರೆ, ಆದರೆ ಈ ಎಂದು

461
00:29:08,490 --> 00:29:11,050
ನೀವು ಸ್ಥಾಪಿಸಲು ಸ್ಥಳವಾಗಿದೆ
ನಿಮ್ಮ ಯೋಜನೆಯನ್ನು ನೀವು ವಾಸ್ತವವಾಗಿ

462
00:29:11,050 --> 00:29:15,180
ಆಪಲ್ ಅಂಗಡಿ ಸಜ್ಜುಗೊಳಿಸಲು ಬಯಸುವ.

463
00:29:15,180 --> 00:29:20,420
>> ಸರಿ, ಅವರ ನೋಡೋಣ
ನಮ್ಮ ಕೋಡ್ ಒಳಗೆ ಎಂದು ಏನೋ.

464
00:29:20,420 --> 00:29:22,360
ಫೈಲ್ ನಾವಿಕ ಮೂಲಕ ಹೋಗಲು ಅವಕಾಶ.

465
00:29:22,360 --> 00:29:30,140
ಮತ್ತು ಈ ಎಲ್ಲಾ ಕಡತಗಳನ್ನು ಎಂದು ಈಗಾಗಲೇ
ಬಹಳ ಸಂತೋಷವನ್ನು ಟೆಂಪ್ಲೇಟ್, ಬಂದಿತು.

466
00:29:30,140 --> 00:29:35,980
ನಾವು ಅವರಿಗೆ ಒಂದು ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ
ಈ ಇದು ಕಾಣುತ್ತದೆ ಏನು.

467
00:29:35,980 --> 00:29:38,530
ಗ್ರಾಂ ಬದಲಾಯಿಸಿ ಹೋಲುತ್ತದೆ.

468
00:29:38,530 --> 00:29:41,340
ಆದರೆ ನೀವು ನೋಡಬಹುದು
ಸಿಂಟ್ಯಾಕ್ಸ್ ಹೈಲೈಟ್ ಬಹುಶಃ

469
00:29:41,340 --> 00:29:42,780
ಸ್ವಲ್ಪ ಒಳ್ಳೆಯದೆಂದು.

470
00:29:42,780 --> 00:29:45,610
ಮತ್ತು ಇದು ವಾಸ್ತವವಾಗಿ ಹೆಚ್ಚು ಇಲ್ಲಿದೆ
ಗ್ರಾಂ ಸಂಪಾದನೆ ಹೆಚ್ಚು ಶಕ್ತಿಶಾಲಿ.

471
00:29:45,610 --> 00:29:49,970
ಮತ್ತು ನೀವು ಸಂಪೂರ್ಣ ಸ್ವಯಂ ಮಾಡಬಹುದು
ನೀವು ಬಹಳಷ್ಟು ಸಂಗತಿಗಳನ್ನು,

472
00:29:49,970 --> 00:29:52,370
ನಾವು ಬೇಗನೆ ನೋಡಬಹುದು ಎಂದು.

473
00:29:52,370 --> 00:29:54,100
>> ಹಾಗೆಯೇ ಡೀಬಗ್ ಪ್ರದೇಶದಲ್ಲಿ ತೆರೆಯಲು ಅವಕಾಶ.

474
00:29:54,100 --> 00:30:02,790

475
00:30:02,790 --> 00:30:07,000
ಸರಿ, ನಾವು ನೋಡಬಹುದು ಎಂದು,
ಕನ್ಸೋಲ್ ಇಲ್ಲಿಯೇ.

476
00:30:07,000 --> 00:30:13,840
ನೀವು ಅಲ್ಲಿ ನೋಡಲು ನೀನು ಏನು
ನೀವು printf ಅಥವಾ ಏನೋ nsloging ಆರ್.

477
00:30:13,840 --> 00:30:17,155
ಮುಂದಿನ ಸಡಗರ ಇಲ್ಲದೆ ಆದ್ದರಿಂದ, ವಾಸ್ತವವಾಗಿ ತಂದೆಯ ಅವಕಾಶ
ಅಪ್ಲಿಕೇಶನ್ ಕಂಪೈಲ್ ಮತ್ತು ಏನಾಗುತ್ತದೆ ನೋಡಿ.

478
00:30:17,155 --> 00:30:20,000

479
00:30:20,000 --> 00:30:23,410
ಒಂದು ಅವಶ್ಯಕ ಲಕ್ಷಣವಾಗಿ ಫಾರ್
ರು ಕೋಡ್ ಆ ರು ಸಂಕೇತ

480
00:30:23,410 --> 00:30:25,850
ಒಂದು ಐಫೋನ್ ಸಿಮ್ಯುಲೇಟರ್ ಬರುತ್ತದೆ.

481
00:30:25,850 --> 00:30:29,820
ಆದ್ದರಿಂದ ನೀವು ಒಂದು ಹೊಂದಿವೆ ಮಾಡಬೇಕಿಲ್ಲ
ಐಫೋನ್, ನಿಮ್ಮ ಯೋಜನೆಯ ಪ್ರಯತ್ನಿಸಿ

482
00:30:29,820 --> 00:30:34,440
ರು ಕೋಡ್ ಆ ಪ್ರತಿಬಿಂಬಿಸುತ್ತದೆ
ನೀವು, ನಾವು ಇದೀಗ ನೋಡಬಹುದು.

483
00:30:34,440 --> 00:30:36,406
>> ಇದು ಬಹಳ ಸಂತೋಷವನ್ನು ಇಲ್ಲಿದೆ.

484
00:30:36,406 --> 00:30:38,640
ಇದು ಸ್ವಲ್ಪ ಕೈಗೊಳ್ಳುತ್ತದೆ
ಸಮಯ ಸ್ವಲ್ಪ ಸಂಕಲಿಸಲು

485
00:30:38,640 --> 00:30:43,040
ಮತ್ತು ಮೂಲತಃ ನಾವು
ಖಾಲಿ ಅಪ್ಲಿಕೇಶನ್,

486
00:30:43,040 --> 00:30:44,640
ಇದು ವಾಸ್ತವವಾಗಿ ಏನನ್ನೂ ಮಾಡುವುದಿಲ್ಲ.

487
00:30:44,640 --> 00:30:46,175
ಆದರೆ ಇದು ಸಂಗ್ರಹಿಸುತ್ತಾ.

488
00:30:46,175 --> 00:30:47,380
ಇದು ಬಹಳ ಉತ್ತಮವಾಗಿದೆ.

489
00:30:47,380 --> 00:30:50,200
ಇದು ಶಬ್ದ, ಸಿ ಹೆಚ್ಚು ಉತ್ತಮ?

490
00:30:50,200 --> 00:30:52,130
ಸರಿ, ನಂತರ ಹೊರಡೋಣ
ಏನೋ ಸೇರಿಸಲು ಪ್ರಯತ್ನಿಸಿ.

491
00:30:52,130 --> 00:30:56,050

492
00:30:56,050 --> 00:31:02,650
ಸ್ವಲ್ಪ ಎಂದು ಒಂದು ಕಡತ
ಇಲ್ಲಿ ವಿಲಕ್ಷಣ ಸ್ಟೋರಿ ಬೋರ್ಡ್ ಕರೆಯಲಾಗುತ್ತದೆ.

493
00:31:02,650 --> 00:31:08,020
ಈ ವಾಸ್ತವವಾಗಿ ಒಂದು ಅದ್ಭುತವಾಗಿದೆ
ರು ಕೋಡ್ ನಾಡಿದು ವೈಶಿಷ್ಟ್ಯವನ್ನು.

494
00:31:08,020 --> 00:31:14,170
ಏಕೆಂದರೆ ರು ಕೋಡ್, ನೀವು ಡ್ರ್ಯಾಗ್ ವಾಸ್ತವವಾಗಿ ಮಾಡಬಹುದು
ಮತ್ತು ಇಂಟರ್ಫೇಸ್ ಮೇಲೆ ಅಂಶಗಳನ್ನು ಬಿಡಿ

495
00:31:14,170 --> 00:31:17,430
ಮತ್ತು ಇದು ನೇರವಾಗಿ ತೋರಿಸುತ್ತವೆ.

496
00:31:17,430 --> 00:31:18,055
ಅವರ ಆ ಪ್ರಯತ್ನಿಸೋಣ.

497
00:31:18,055 --> 00:31:21,230

498
00:31:21,230 --> 00:31:27,236
>> ನಾವು, ಇಲ್ಲಿ "ಹಲೋ ವರ್ಲ್ಡ್ !!!" ಒಂದು ಲೇಬಲ್ ಬಿಡಿ

499
00:31:27,236 --> 00:31:29,740
ನಾವು ಆ ಕೇಂದ್ರೀಕರಿಸಬಹುದು.

500
00:31:29,740 --> 00:31:30,970
ಸುಂದರವಾಗಿದೆ.

501
00:31:30,970 --> 00:31:33,915
ಈಗ ಈ ಸ್ಟಾಪ್ ಸಿಮ್ಯುಲೇಶನ್ ರನ್ ಅವಕಾಶ.

502
00:31:33,915 --> 00:31:36,940

503
00:31:36,940 --> 00:31:38,700
ಇಲ್ಲಿ ನಾವು "ಹಲೋ ವರ್ಲ್ಡ್ !!!" ಹೊಂದಿವೆ

504
00:31:38,700 --> 00:31:40,810
ನಾವು ಇನ್ನೂ ಯಾವುದೇ ಕೋಡಿಂಗ್ ಕಾಣಲಿಲ್ಲ.

505
00:31:40,810 --> 00:31:42,750
ಬೀಟಿಂಗ್ ಏನಾಗುತ್ತಿದೆ?

506
00:31:42,750 --> 00:31:45,880
ಈ ಹೇಗೆ ಬಲಶಾಲಿ
ಇಂಟರ್ಫೇಸ್ ಬಿಲ್ಡರ್ ಮಾಡಬಹುದು.

507
00:31:45,880 --> 00:31:48,030
ಯಾರಾದರೂ ಸಹ ಹೇಳಿದರು
ನೀವು ಬಹುಶಃ ಕೇವಲ

508
00:31:48,030 --> 00:31:52,800
ಬರೆಯದೆ ಅಪ್ಲಿಕೇಶನ್ ಪೂರ್ಣಗೊಳಿಸಲು
ಕೋಡ್ ಆಫ್ ಬಹುಶಃ ಒಂದು ಸಾವಿರ ಸಾಲುಗಳು

509
00:31:52,800 --> 00:31:54,820
ಕೇವಲ ಇಂಟರ್ಫೇಸ್ ಬಿಲ್ಡರ್ ಬಳಸಿಕೊಂಡು.

510
00:31:54,820 --> 00:31:59,680
ಆದರೆ ಬಹುಶಃ ಅಲ್ಲ
ಉತ್ತಮ ರೀತಿಯಲ್ಲಿ ಅದನ್ನು.

511
00:31:59,680 --> 00:32:01,670
>> ಈಗ ನಿಜವಾಗಿಯೂ ಕೋಡಿಂಗ್ ಕೆಳಗೆ ಪಡೆಯಲು ಅವಕಾಶ.

512
00:32:01,670 --> 00:32:04,860

513
00:32:04,860 --> 00:32:08,330
ಕಡತ ರಚನೆ
ವಾಸ್ತವವಾಗಿ ನಿಜವಾಗಿಯೂ ಆಸಕ್ತಿದಾಯಕವಾಗಿದೆ

514
00:32:08,330 --> 00:32:15,610
ಏಕೆಂದರೆ ನೀವು ನೋಡಬಹುದು ಎಂದು, ಅಲ್ಲಿ
ನಗರದಲ್ಲಿ ಯಾವುದೇ ಪ್ರಮುಖ ಕಾರ್ಯವನ್ನು ಹೊಂದಿದೆ.

515
00:32:15,610 --> 00:32:17,466
ನೋಡಿ?

516
00:32:17,466 --> 00:32:19,340
ನಾವು ಮೊದಲೇ ಹೇಳಿದಂತೆ,
ಈ ಎಂದು ನೋಡಬಹುದು

517
00:32:19,340 --> 00:32:22,830
ಅಳವಡಿಕೆಯಾಗಿದೆ ಕಡತವಾಗಿರುತ್ತದೆ
ನಿರ್ದಿಷ್ಟ ವರ್ಗ.

518
00:32:22,830 --> 00:32:25,690
ಆದರೆ ಮುಖ್ಯ ನಗರದಲ್ಲಿ ಇಲ್ಲ.

519
00:32:25,690 --> 00:32:27,490
ಆದ್ದರಿಂದ ಅಲ್ಲಿ ಮುಖ್ಯ ಆಗಿದೆ?

520
00:32:27,490 --> 00:32:31,970
ವಾಸ್ತವವಾಗಿ, ಅಲ್ಲಿ ಒಂದು ಮುಖ್ಯ, ಆದರೆ
ಮುಖ್ಯ ವಾಸ್ತವವಾಗಿ ನೀವು ಮುಚ್ಚಿಡಲು.

521
00:32:31,970 --> 00:32:34,560
ಮುಖ್ಯ ಇಲ್ಲಿದೆ.

522
00:32:34,560 --> 00:32:37,120
ಪರಿಚಿತ ಕಾಣುತ್ತದೆ.

523
00:32:37,120 --> 00:32:41,000
>> ಆದ್ದರಿಂದ ಮೂಲಭೂತವಾಗಿ ಏನು ಐಒಎಸ್
ಮುಖ್ಯ ಒಳಗೆ ಮಾಡುತ್ತಿರುವ

524
00:32:41,000 --> 00:32:43,540
ಮುಖ್ಯ ಬಂದ ಎಂದು
ಮೂಲತಃ ಇದು, ಎಂದು

525
00:32:43,540 --> 00:32:49,000
ಅಪ್ಲಿಕೇಶನ್, ಇದು ಕಾರ್ಯರೂಪಕ್ಕೆ ಬಂದ
AppDelegate ಎಂಬ ವಸ್ತು ಸೃಷ್ಟಿಸುತ್ತದೆ.

526
00:32:49,000 --> 00:32:52,980

527
00:32:52,980 --> 00:32:57,350
ನಾನು ಮೊದಲೇ ಹೇಳಿದಂತೆ, ಇಡೀ
ಅಪ್ಲಿಕೇಶನ್ ವಾಸ್ತವವಾಗಿ ಸ್ವತಃ ಒಂದು ವಸ್ತು.

528
00:32:57,350 --> 00:33:02,270
ಮೂಲತಃ, ಈ ರೀತಿಯಲ್ಲಿ ಆದ್ದರಿಂದ
ಐಒಎಸ್ ಅಪ್ಲಿಕೇಶನ್ ಕಂಪೈಲರ್ ಹೇಳುತ್ತಿದೆ

529
00:33:02,270 --> 00:33:05,540
ಸರಿ, ನಾನು ರಚಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ
AppDelegate ಎಂಬ ಉತ್ಪನ್ನ,

530
00:33:05,540 --> 00:33:07,620
ಮತ್ತು ನನ್ನ ಅಪ್ಲಿಕೇಶನ್ ಏರಲಿದೆ.

531
00:33:07,620 --> 00:33:09,640
ಆದ್ದರಿಂದ ನೀವು ಹೋಗಿ ಅಗತ್ಯವಿದೆ
ಎಂದು AppDelegate ಮೂಲಕ

532
00:33:09,640 --> 00:33:12,040
ಮತ್ತು ಆ ವ್ಯಕ್ತಿ ಏನು ನೋಡಲು.

533
00:33:12,040 --> 00:33:14,850
ನನ್ನ ಕೆಲಸ ನನಗೆ ಮಾಡಲಾಗುತ್ತದೆ.

534
00:33:14,850 --> 00:33:22,070
>> ಮತ್ತು AppDelegate ನೀವು ನೋಡಬಹುದು
ಕೆಲವು ನಿಜವಾಗಿಯೂ ವಿಲಕ್ಷಣ ಕಾರ್ಯಗಳಿವೆ

535
00:33:22,070 --> 00:33:25,290
ನಿಜವಾಗಿಯೂ ವಿಧಾನಗಳು, ಎಂದು
ಆಪಲ್ ಈಗಾಗಲೇ ನೀಡಿದೆ.

536
00:33:25,290 --> 00:33:27,464
ಈ ಯಾವುವು?

537
00:33:27,464 --> 00:33:31,010
ಈ ವಾಸ್ತವವಾಗಿ ಕೇವಲ ಪ್ರೋಟೋಕಾಲ್ಗಳೆಂದರೆ
ಎಂದು ನನ್ನ ಬಗ್ಗೆ.

538
00:33:31,010 --> 00:33:35,670
ಆದ್ದರಿಂದ ಈ ಘಟನೆಗಳ ಎಂದು ಆಪಲ್
ಆರಂಭಿಸಲು ನೀವು ನೀಡಿದೆ.

539
00:33:35,670 --> 00:33:38,050
ಏನೂ ಕೆಲವು ಇಲ್ಲ
ಇದೀಗ ಕಾರ್ಯಗಳನ್ನು,

540
00:33:38,050 --> 00:33:40,820
ಆದರೆ ನಾವು ಆರಂಭಿಸಲು ಬಯಸಿದರೆ
ನಮ್ಮ ಅಪ್ಲಿಕೇಶನ್ ಏನನ್ನಾದರೂ

541
00:33:40,820 --> 00:33:46,140
ಕ್ಲಿಕ್ ಪಡೆಯುವಲ್ಲಿ ಮೊದಲು
ಯಾವುದೇ ದೃಷ್ಟಿಯಿಂದ, ನಾವು ಇಲ್ಲಿ ಹಾಗೆ.

542
00:33:46,140 --> 00:33:51,150
>> ನೀವು ಹೆಸರು ಓದಬಹುದು ಮತ್ತು ನಾನು ಭಾವಿಸುತ್ತೇನೆ
ಕ್ರಿಯೆಯನ್ನು ವಾಸ್ತವವಾಗಿ ನಿಜವಾಗಿಯೂ ಸ್ಪಷ್ಟವಾಗುತ್ತದೆ.

543
00:33:51,150 --> 00:33:54,160

544
00:33:54,160 --> 00:33:58,350
ಈಗ ಮುಖ್ಯ ಸೃಷ್ಟಿಸಿದೆ
AppDelegate ವಸ್ತುವಿನ.

545
00:33:58,350 --> 00:34:05,220
ಮತ್ತು AppDelegate ಮಾಡಲು ಏನಾಗುತ್ತಿದೆ
ವಾಸ್ತವವಾಗಿ ಸಹ ನೀವು ಮುಚ್ಚಿಡಲು.

546
00:34:05,220 --> 00:34:09,250
AppDelegate ಆರಂಭಿಸಲು ಹೋಗುತ್ತದೆ
ViewController ಸ್ಟಾಕ್ ಲೋಡ್.

547
00:34:09,250 --> 00:34:13,170
ಆದ್ದರಿಂದ ಮೂಲತಃ ಆರಂಭಿಸಲು ವಿಶೇಷವೇನು
ನೀವು ಹೊಂದಿರುವ ಎಲ್ಲಾ ವೀಕ್ಷಣೆಗಳು ಅಪ್ ಲೋಡ್

548
00:34:13,170 --> 00:34:17,500
ಮತ್ತು ಕೇವಲ ವೀಕ್ಷಿಸಿ ನಿರೂಪಿಸಲು
ಕ್ರಮಾನುಗತ ಆಧರಿಸಿ.

549
00:34:17,500 --> 00:34:21,280
>> ಆದ್ದರಿಂದ ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಮಾತ್ರ ಹೊಂದಿವೆ
ಇಲ್ಲಿ ಇದು ಒಂದು ನೋಟ.

550
00:34:21,280 --> 00:34:25,060
ಇದರಿಂದ ಮಾತ್ರ ಚಿತ್ರಣವಾಗಿದೆ
ಎಂದು ಎಂದು ವಿಶೇಷವೇನು.

551
00:34:25,060 --> 00:34:28,159
ViewController ತರ್ಕ ಇಲ್ಲಿಯೇ.

552
00:34:28,159 --> 00:34:32,159
ಈ ವಾಸ್ತವವಾಗಿ ಸಂಕೇತ
ನಾವು ನೋಡಿದ ವೀಕ್ಷಿಸಿ ನಿಯಂತ್ರಿಸುತ್ತದೆ.

553
00:34:32,159 --> 00:34:33,679
ಸರಿ, ಇಲ್ಲಿ ಏನಾದರೂ ಮಾಡೋಣ.

554
00:34:33,679 --> 00:34:44,030

555
00:34:44,030 --> 00:34:50,560
ಆದ್ದರಿಂದ viewDidLoad ಕ್ರಿಯೆಯನ್ನು ರೀತಿಯಲ್ಲಿ ಧ್ವನಿಸುತ್ತದೆ,
ಈ ಒಂದು ಪ್ರತಿನಿಧಿಯನ್ನು ವಾಸ್ತವವಾಗಿ,

556
00:34:50,560 --> 00:34:52,500
ಇದು ಒಂದು ಪ್ರೋಟೋಕಾಲ್.

557
00:34:52,500 --> 00:34:56,350
>> ಆದ್ದರಿಂದ ವೀಕ್ಷಿಸಿ, ಲೋಡ್ ಯಾವುದೇ
ಕಾರ್ಯ ಒಳಗೆ ಎಲ್ಲವನ್ನೂ

558
00:34:56,350 --> 00:34:57,920
ಕರೆಯಬಹುದು.

559
00:34:57,920 --> 00:35:02,840
ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಹಲೋ "ನೋಡಿ
Tianyu! "ನಾವು ಪ್ರೋಗ್ರಾಂ.

560
00:35:02,840 --> 00:35:09,820

561
00:35:09,820 --> 00:35:12,842
ಇದು ಸ್ವಲ್ಪ ನಿಧಾನ ಪ್ರಕಟಗೊಳ್ಳಲಿದೆ
ಸ್ಟೋರಿ ಬೋರ್ಡ್ ಕಡತಗಳನ್ನು ಕಂಪೈಲ್.

562
00:35:12,842 --> 00:35:15,440

563
00:35:15,440 --> 00:35:18,190
ಚೆನ್ನಾಗಿ ವಾಸ್ತವವಾಗಿ, ನಾವು ಒಂದು ಔಟ್ಪುಟ್ ನೋಡುತ್ತಾರೆ.

564
00:35:18,190 --> 00:35:20,720
ಇದು ತುಂಬಾ ಸುಂದರವಾಗಿದೆ ಇಲ್ಲಿದೆ.

565
00:35:20,720 --> 00:35:22,000
ಈಗ ನಿಜವಾಗಿಯೂ ಮಾರಿಯೋ ಮಾಡಿ.

566
00:35:22,000 --> 00:35:25,400

567
00:35:25,400 --> 00:35:27,625
ನಾನು ವ್ಯಾಖ್ಯಾನಿಸಲು ಪಡೆಯಲಿದ್ದೇನೆ
ಬೇಗನೆ ಕೆಲಸ.

568
00:35:27,625 --> 00:35:31,510

569
00:35:31,510 --> 00:35:54,245
marioWithLevels: (ಇಂಟ್) ಮಟ್ಟದ ಫಲಿತಾಂಶಗಳು.

570
00:35:54,245 --> 00:36:01,120

571
00:36:01,120 --> 00:36:06,410
>> ಸರಿ, ಈ ವಾಸ್ತವವಾಗಿ ನಿಜಕ್ಕೂ
ರು ಕೋಡ್ ಸ್ವಯಂ ಪೂರ್ಣಗೊಂಡ ವೈಶಿಷ್ಟ್ಯ.

572
00:36:06,410 --> 00:36:10,680
ಆದ್ದರಿಂದ ನೀವು ಬರೆಯಲು ಮತ್ತು ನಮೂದಿಸಿ ಟೈಪ್,
ಇದು ಈಗಾಗಲೇ ಟೆಂಪ್ಲೇಟ್ ನೀಡಿದ

573
00:36:10,680 --> 00:36:12,325
ನೀವು, ಇದು ತುಂಬಾ ಸುಂದರವಾಗಿದೆ.

574
00:36:12,325 --> 00:36:50,480

575
00:36:50,480 --> 00:36:52,850
ನಿಜಕ್ಕೂ ತೋರಬೇಕು
ನೀವು ಹುಡುಗರಿಗೆ ಪರಿಚಿತ.

576
00:36:52,850 --> 00:36:55,940

577
00:36:55,940 --> 00:36:59,680
ಕ್ಷಮಿಸಿ, ನನ್ನ ತಪ್ಪು.

578
00:36:59,680 --> 00:37:15,790

579
00:37:15,790 --> 00:37:18,120
ಸರಿ, ತಂಪಾದ.

580
00:37:18,120 --> 00:37:22,710
ತರ್ಕ ನಿಜವಾಗಿಯೂ ಪರಿಚಿತ ತೋರಬೇಕು
ನೀವು ಹುಡುಗರಿಗೆ, ಅದರಲ್ಲೂ ಕೇವಲ ಮಾರಿಯೋ ಗೆ.

581
00:37:22,710 --> 00:37:26,140
>> ಆದರೆ ನಾವು ಈಗ ಮುದ್ರಿಸುತ್ತದೆ
ಕನ್ಸೋಲ್ ಪ್ರತಿಯೊಂದು ಸಮಯ,

582
00:37:26,140 --> 00:37:29,280
ನಾವು ಹೇಗಾದರೂ ಇರಿಸಿಕೊಳ್ಳಲು ಬಯಸುವ ಏಕೆಂದರೆ
ನಾವು ಮುದ್ರಿಸುವ ಏನು ಟ್ರ್ಯಾಕ್.

583
00:37:29,280 --> 00:37:31,810
ನಾವು ಬಳಸಲು ನೀನು
ನಂತರ ಹೇಗೋ ಫಲಿತಾಂಶಗಳು,

584
00:37:31,810 --> 00:37:35,010
ಮುದ್ರಣ ಪ್ರದರ್ಶಿಸಲು
ಔಟ್ ಬಳಕೆದಾರರಿಗೆ ಕಾರಣವಾಗುತ್ತದೆ.

585
00:37:35,010 --> 00:37:37,730
ಆದ್ದರಿಂದ ಬದಲಿಗೆ ನಾವು ಆರ್
ಎಲ್ಲವನ್ನೂ nslogging,

586
00:37:37,730 --> 00:37:42,410
ಇದು ನಾವು ಎಲ್ಲವನ್ನೂ ಸಂಗ್ರಹಿಸಲು ನೀವು
ಒಂದು ಕಾರ್ಯ ಕರೆ ಪರಿಣಾಮವಾಗಿ ಆಗಿ,

587
00:37:42,410 --> 00:37:44,070
ಆದರೆ ತರ್ಕ ಒಂದೇ ಆಗಿದೆ.

588
00:37:44,070 --> 00:37:48,030

589
00:37:48,030 --> 00:37:51,800
ನಾವು, ನಾವು ಮುಗಿಸಿದ ನಂತರ
ನಮ್ಮ ಫಲಿತಾಂಶಗಳನ್ನು ಮುದ್ರಿಸಲು.

590
00:37:51,800 --> 00:37:59,330

591
00:37:59,330 --> 00:38:04,970
>> ಇಲ್ಲಿ ಬದಲಿಗೆ ಮುದ್ರಿಸುವ ನನ್ನ
ಹೆಸರು, ನಾವು ಒಂದು ಕಾರ್ಯ ಕರೆ ನೀನು.

592
00:38:04,970 --> 00:38:15,340

593
00:38:15,340 --> 00:38:18,090
ನ ಏನಾಗುತ್ತದೆ ನೋಡೋಣ.

594
00:38:18,090 --> 00:38:21,240
ಓಹ್, ನಿಸ್ಸಂಶಯವಾಗಿ.

595
00:38:21,240 --> 00:38:24,320
ನಾವು ಒಂದು ಸಂತೋಷವನ್ನು ಹೊಂದಿಲ್ಲ
ಔಟ್ ಇಲ್ಲಿ ಸ್ವಲ್ಪ ಪಿರಮಿಡ್.

596
00:38:24,320 --> 00:38:28,370
ಈ ಮೂಲತಃ C ಆಗಿದೆ, ನಾವು ಆರ್
ನೀವು ಒಂದು ಕಾರ್ಯ ಕರೆ ಅಲ್ಲಿ ಮ್ಯಾನಿಪುಲೇಟ್

597
00:38:28,370 --> 00:38:30,010
ಮತ್ತು ಹೇಗೆ ಒಂದು ಕ್ರಿಯೆ ನೋಡಲು ಹೇಗಿದೆ.

598
00:38:30,010 --> 00:38:31,560
ಬೇರೆ ಇಲ್ಲ.

599
00:38:31,560 --> 00:38:34,040
ಆದರೆ ಈ ವಾಸ್ತವವಾಗಿ
ಬಹಳ ರೋಮಾಂಚಕಾರಿ ಇಲ್ಲಿ,

600
00:38:34,040 --> 00:38:37,500
ನಾವು ನೋಡಿದ ಇಲ್ಲ ಏಕೆಂದರೆ
ಐಫೋನ್ ಅಪ್ಲಿಕೇಶನ್ ಏನು.

601
00:38:37,500 --> 00:38:42,120
>> ಆದ್ದರಿಂದ ವಾಸ್ತವವಾಗಿ app-- ಒಂದು ಐಫೋನ್ ಹೊಂದಿದ್ದರೆ
ನೀವು ನಿಜವಾಗಿಯೂ ಮಾರಿಯೋ ಐಒಎಸ್ ಬಲ ಹೊಂದಿದ್ದರೆ

602
00:38:42,120 --> 00:38:45,080
ಈಗ, ನೀವು ಹೋಗುತ್ತಿಲ್ಲ
ಏನು ನೋಡಲು ಎಂದು

603
00:38:45,080 --> 00:38:49,450
ಏಕೆಂದರೆ ಮಾರಿಯೋ ಮಾಡಲು ಏನು ಹೊಂದಿದೆ
ಒಂದು ಕನ್ಸೋಲ್ ಎಲ್ಲಾ ಆ ಉತ್ಪನ್ನಗಳು

604
00:38:49,450 --> 00:38:51,620
ಒಂದು ಬಳಕೆದಾರರಿಂದ ಮರೆಮಾಡಲಾಗಿದೆ.

605
00:38:51,620 --> 00:38:53,850
ಈ, ನೀವು ನೋಡಿ ಏನು
ಇದು "ಹಲೋ ವರ್ಲ್ಡ್ !!!" ಆಗಿದೆ

606
00:38:53,850 --> 00:38:55,720
ಉತ್ತಮ ಅಲ್ಲ.

607
00:38:55,720 --> 00:39:03,090
ಈಗ ಬಳಕೆದಾರ ನೋಡಿ ಮಾಡಲು ಪ್ರಯತ್ನಿಸೋಣ
ಎಂಬುದನ್ನು ನಾವು ಔಟ್ ಮುದ್ರಿಸುವ.

608
00:39:03,090 --> 00:39:06,000
ನಾವು ಇನ್ನು ಮುಂದೆ ಲೇಬಲ್ ಅಗತ್ಯವಿಲ್ಲ.

609
00:39:06,000 --> 00:39:09,800
ನ ಪ್ರಯತ್ನಿಸೋಣ ಮತ್ತು ಏನೋ ಲೆಕ್ಕಾಚಾರ
ಬೇರೆ ಉಪಯೋಗಕ್ಕೆ ಬರುತ್ತದೆ.

610
00:39:09,800 --> 00:39:12,140
>> ವಾಸ್ತವವಾಗಿ ಒಂದು ಇಲ್ಲ
ಎಂದು ನಿಗದಿಪಡಿಸಲಾಗಿದೆ ಅಂಶ

611
00:39:12,140 --> 00:39:16,460
ಪಠ್ಯ ಕ್ಷೇತ್ರದಲ್ಲಿ ಸಾಧ್ಯವೋ
ನಮಗೆ ಬಹಳ ಸಹಾಯವಾಗುತ್ತದೆ.

612
00:39:16,460 --> 00:39:19,880
ಇದು ಮೂಲತಃ ಒಂದು ಪ್ರದೇಶದಲ್ಲಿ ತೋರಿಸುತ್ತದೆ
ಪಠ್ಯದ ಸಂಪಾದನೆ ಮಾಡಬಹುದಾದ.

613
00:39:19,880 --> 00:39:22,320
ಆದ್ದರಿಂದ ನಿಜವಾಗಿಯೂ ಸಹಾಯಕವಾಗಿದೆಯೆ ಕಾಣುತ್ತದೆ.

614
00:39:22,320 --> 00:39:23,810
ಈಗ ಎಳೆಯಿರಿ ಮತ್ತು ಅದನ್ನು ಬಿಟ್ಟು ಬಿಡಿ.

615
00:39:23,810 --> 00:39:26,880

616
00:39:26,880 --> 00:39:32,670
ವಾಹ್, ನಾವು ಒಂದು ಪಠ್ಯ ವೀಕ್ಷಣೆ ಹೊಂದಿವೆ
ನಮ್ಮ ದೃಷ್ಟಿಯಲ್ಲಿ, ನಿಜವಾಗಿಯೂ ಅಲಂಕಾರಿಕ.

617
00:39:32,670 --> 00:39:35,430
ಎಂದು ಸ್ವಲ್ಪ ತುಂಬಾ ದೊಡ್ಡದಾಗಿದೆ.

618
00:39:35,430 --> 00:39:38,150
ನ ಸಣ್ಣ ಮಾಡಲು ಅವಕಾಶ.

619
00:39:38,150 --> 00:39:40,290
ಸೆಂಟರ್ ಹಾಕಿದರೆ.

620
00:39:40,290 --> 00:39:43,760
ಹಾಗೂ ಸಣ್ಣ ಮಾಡಲು.

621
00:39:43,760 --> 00:39:50,110
>> ಈಗ ನಾವು ಇದು ಸಾಧ್ಯವೋ, ಒಂದು ಪಠ್ಯ ವೀಕ್ಷಣೆ ಹೊಂದಿವೆ
ನಮ್ಮ ಅಂತಿಮ ಪರಿಣಾಮವಾಗಿ ಪ್ರದರ್ಶಿಸಲು ಬಳಸಬಹುದು.

622
00:39:50,110 --> 00:39:52,860
ಆದರೆ ಇದೀಗ ಅದು
ಖಂಡಿತವಾಗಿ ಕೆಲಸಕ್ಕೆ ಹೋಗುತ್ತಿಲ್ಲ

623
00:39:52,860 --> 00:39:56,970
no-- ಇರುವುದರಿಂದ
ViewController ನಾವು

624
00:39:56,970 --> 00:40:03,010
ಗೊತ್ತಿಲ್ಲ ವ್ಯಾಖ್ಯಾನಿಸಲಾಗಿದೆ
ಅಲ್ಲಿಗೆ ಒಂದು ಪಠ್ಯ ವೀಕ್ಷಣೆ ಇಲ್ಲ.

625
00:40:03,010 --> 00:40:06,550
ನಾವು ಹೇಗೋ ಅಗತ್ಯವಿದೆ
ಪಠ್ಯ ವೀಕ್ಷಣೆ ಸಂಪರ್ಕ ನಾವು

626
00:40:06,550 --> 00:40:11,660
ವರ್ಗ ರಚಿಸಿದ
ಈಗಾಗಲೇ ನಮ್ಮೊಂದಿಗೆ ಬಂದಿದ್ದಾರೆ.

627
00:40:11,660 --> 00:40:14,860
>> ನಾವು ಹಾಗೆ ದಾರಿ
ವಾಸ್ತವವಾಗಿ ನಿಜವಾಗಿಯೂ ಮಾಂತ್ರಿಕ.

628
00:40:14,860 --> 00:40:18,190
ಆದ್ದರಿಂದ ಸ್ಟೋರಿ ಬೋರ್ಡ್ ತೆರೆಯುತ್ತದೆ.

629
00:40:18,190 --> 00:40:22,220
ಇಲ್ಲ ವಿಶೇಷ [ಕೇಳಿಸುವುದಿಲ್ಲ]
[ಎಂದು? ಸಹಾಯಕ?] [ಕೇಳಿಸುವುದಿಲ್ಲ].

630
00:40:22,220 --> 00:40:25,190
ನೀವು ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ, ಇದು ಇಲ್ಲಿದೆ
ಎರಡು ಕಡತಗಳನ್ನು ತೆರೆಯಲು ಹೋಗುವ.

631
00:40:25,190 --> 00:40:29,425
ಒಂದು ವರ್ಗ ಮತ್ತು ಇತರ ಒಂದಾಗಿದೆ
ಇದು ಒಂದು ಅನುಗುಣವಾದ ಚಿತ್ರಣವಾಗಿದೆ.

632
00:40:29,425 --> 00:40:31,920
ಇದು ತುಂಬಾ ಉಪಯುಕ್ತ.

633
00:40:31,920 --> 00:40:35,950
ಮತ್ತು ಅವರ H ಕಡತವನ್ನು ಸಾಗುವ ಅವಕಾಶ.

634
00:40:35,950 --> 00:40:39,110
ನಿಯಂತ್ರಣ, ಈ [ಕೇಳಿಸುವುದಿಲ್ಲ] ತರ್ಕ.

635
00:40:39,110 --> 00:40:47,280
ಕಂಟ್ರೋಲ್ ಒತ್ತಿ ಮತ್ತು ಡ್ರ್ಯಾಗ್
ಘೋಷಣೆ ಪಠ್ಯ ವೀಕ್ಷಿಸಿ.

636
00:40:47,280 --> 00:40:48,780
ನಾವು ಆ outputView ಕರೆಯಲು ನೀನು.

637
00:40:48,780 --> 00:40:52,189

638
00:40:52,189 --> 00:40:53,670
ಸಂಪರ್ಕಿಸಿ.

639
00:40:53,670 --> 00:40:59,420
ಇಲ್ಲಿ ನಾವು ಒಂದು ಹೊಸ ಘೋಷಿಸಿದರು
ನಮ್ಮ ViewController ವರ್ಗ ಆಸ್ತಿ.

640
00:40:59,420 --> 00:41:02,300
ಮತ್ತು ಹೊಸ ಆಸ್ತಿ
ಕೇವಲ ಪಠ್ಯ ವೀಕ್ಷಣೆ ಆಗಿದೆ

641
00:41:02,300 --> 00:41:05,000
ನಾವು ಇಂಟರ್ಫೇಸ್ ಕಟ್ಟಡದಲ್ಲಿ ರಚಿಸಿದ.

642
00:41:05,000 --> 00:41:07,990
ಆ ರೀತಿಯಲ್ಲಿ ನಾವು ಆದ್ದರಿಂದ
ಅವಕಾಶವಿರಬೇಕು ಮಾಹಿತಿ

643
00:41:07,990 --> 00:41:13,630
ಮತ್ತು ಒಳಗೆ ಎಂದು ಎಲ್ಲವನ್ನೂ ಕುಶಲತೆಯಿಂದ
ನಿಜಕ್ಕೂ ಇದು ಔಟ್ಪುಟ್ ನೋಟ.

644
00:41:13,630 --> 00:41:19,260
>> , ನಮ್ಮ ನಿಜವಾದ ಕೋಡ್ ಆದ್ದರಿಂದ
ಅದನ್ನು ಏನಾದರೂ ಮಾಡಿ.

645
00:41:19,260 --> 00:41:23,810
ಆದ್ದರಿಂದ ಈ ಬಾರಿ ನಾವು ಮುದ್ರಣ ಹಾಗೆ ಆಗ
ಅಂತಿಮ ಪರಿಣಾಮವಾಗಿ ಔಟ್ ಮಾರಿಯೋ,

646
00:41:23,810 --> 00:41:28,020
ನಾವು ಏನು ಲಾಗ್ ಅಲ್ಲ ಕೋರುತ್ತೇವೆ.

647
00:41:28,020 --> 00:41:30,080
ನಾವು ಇರಿಸಿಕೊಳ್ಳಲು ಎಂದು ಅರ್ಥ
ಲಾಗಿಂಗ್ ಹೇಳಿಕೆ.

648
00:41:30,080 --> 00:41:41,490
ಅದಕ್ಕೆ ಜೊತೆಯಾಗಿ, ನಾವು
ವಿವರಿಸುವ ಕಳುಹಿಸಲು ನಾವು

649
00:41:41,490 --> 00:41:47,622
ಔಟ್ಪುಟ್ ದೃಷ್ಟಿಕೋನಕ್ಕೆ ರಚಿಸಿದ
ನಾವು ದಾಖಲಿಸಿದವರು TextView ಒಂದು UI.

650
00:41:47,622 --> 00:41:48,746
ಈಗ ಏನಾಗುತ್ತದೆ ನೋಡೋಣ.

651
00:41:48,746 --> 00:41:54,470

652
00:41:54,470 --> 00:41:56,620
ವಾಹ್.

653
00:41:56,620 --> 00:41:59,130
ನಾವು ಇದೀಗ ಅಪ್ಲಿಕೇಶನ್ ಒಂದು ಪಿರಮಿಡ್ ಹೊಂದಿವೆ.

654
00:41:59,130 --> 00:42:06,720
>> ಬಳಕೆದಾರ ನಮ್ಮ ಔಟ್ಪುಟ್ ಏಕೆಂದರೆ ನೋಡಬಹುದು
ನಾವು ನಮ್ಮ ಕೋಡ್ ಉತ್ಪತ್ತಿಯನ್ನು ನಕಲಿಸಿದ

655
00:42:06,720 --> 00:42:08,045
ನಮ್ಮ ಇಂಟರ್ಫೇಸ್.

656
00:42:08,045 --> 00:42:10,950
ಇದು ಬಹಳ ಒಳ್ಳೆಯದು.

657
00:42:10,950 --> 00:42:14,990
ಇದು ವಾಸ್ತವವಾಗಿ ಅಲ್ಲ
ಉತ್ತೇಜಕ ನಾವು can-- ಕಾರಣ

658
00:42:14,990 --> 00:42:18,250
ಎಲ್ಲಾ ಅಪ್ಲಿಕೇಶನ್ ರೀತಿ ಇದೆ
ನೀವು ಒಂದು ಪಿರಮಿಡ್ ತೋರಿಸುವ,

659
00:42:18,250 --> 00:42:20,520
ಮತ್ತು ನೀವು ಅದರ ಬಗ್ಗೆ ಮಾಡಬಹುದು ಇಲ್ಲ.

660
00:42:20,520 --> 00:42:22,330
ಇದು ವಿಶೇಷವಾಗಿ ಅದ್ಭುತ ಅಲ್ಲ.

661
00:42:22,330 --> 00:42:27,840
ಆದ್ದರಿಂದ ಈಗ ಬಟನ್ ಮಾಡೋಣ
ವೀಕ್ಷಣೆಗಳು ತೆರವುಗೊಳಿಸುತ್ತದೆ.

662
00:42:27,840 --> 00:42:30,290
ಒಂದು ಬಟನ್ ಸಹಾಯ ಎಂದು ತೋರುತ್ತದೆ.

663
00:42:30,290 --> 00:42:33,270
ಎಳೆಯಿರಿ ಮತ್ತು ಬಿಡಿ.

664
00:42:33,270 --> 00:42:33,900
ಬಟನ್ ಒಂದು.

665
00:42:33,900 --> 00:42:36,730

666
00:42:36,730 --> 00:42:37,320
ಬಟನ್ ಎರಡು.

667
00:42:37,320 --> 00:42:49,170

668
00:42:49,170 --> 00:42:52,052
>> ನಾವು ಎಡ ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ
ಬಟನ್, ವೀಕ್ಷಿಸಿ ತೆರವುಗೊಳಿಸಿ ಮಾಡಬೇಕು.

669
00:42:52,052 --> 00:42:53,635
ತೆರೆಯ ಮೇಲೆ ಏನನ್ನೂ ಇರಬೇಕು.

670
00:42:53,635 --> 00:42:56,970
ಮತ್ತು ನಾವು ಕ್ಲಿಕ್ ಮಾಡಿದಾಗ
ಬಲ ಗುಂಡಿಯನ್ನು, ಮಾರಿಯೋ,

671
00:42:56,970 --> 00:42:59,740
ವೀಕ್ಷಣೆ ಮತ್ತೆ ಕಾಣಿಸಿಕೊಳ್ಳಲು ಹೋಗುತ್ತದೆ.

672
00:42:59,740 --> 00:43:05,510
ಆದ್ದರಿಂದ ಈ ರೀತಿಯಲ್ಲಿ ನಾವು ಕೂಡ
ಮ್ಯಾಜಿಕ್ ವಿಷಯವನ್ನು, ನಿಯಂತ್ರಣ ಮತ್ತು ಡ್ರ್ಯಾಗ್

673
00:43:05,510 --> 00:43:08,740
ವರ್ಗ ಘೋಷಣೆಗೆ
ಸಹಾಯಕ director-- ರಲ್ಲಿ

674
00:43:08,740 --> 00:43:11,600
ಸಹಾಯಕ ವೀಕ್ಷಕದಲ್ಲಿ.

675
00:43:11,600 --> 00:43:18,620
ಈ ಸಂದರ್ಭದಲ್ಲಿ ನಾವು ಸೂಚಿಸುವ ಮಾಡಲಾಗುತ್ತದೆ
ಆ ಕ್ರಿಯಾಶೀಲ ಇರಬೇಕು.

676
00:43:18,620 --> 00:43:19,120
clearMario.

677
00:43:19,120 --> 00:43:21,650

678
00:43:21,650 --> 00:43:26,830
>> ಇಲ್ಲಿ ನಾವು ಈಗಾಗಲೇ ರಚಿಸಿದ
clearMario ಎಂಬ ಕ್ರಿಯಾಶೀಲ,

679
00:43:26,830 --> 00:43:34,210
ಇದು ಎಂದು ಎಂದು ವಿಧಾನ
ನಾವು ಬಟನ್ ಸ್ಪಷ್ಟ ಒತ್ತಿ ಬಂದ.

680
00:43:34,210 --> 00:43:41,030
ನಮ್ಮ ವಾಸ್ತವವಾಗಿ ಕೋಡ್ ಆದ್ದರಿಂದ, ಕೇವಲ ತಂದೆಯ ಅವಕಾಶ
ಔಟ್ಪುಟ್ ಪಠ್ಯ ಮತ್ತು ಔಟ್ಪುಟ್ ವೀಕ್ಷಿಸಿ ಪುಟ್

681
00:43:41,030 --> 00:43:44,620
ಏನೂ ಆಗಿ, ಮತ್ತು ಆ ರೀತಿಯಲ್ಲಿ
ಇದು ಸ್ಪಷ್ಟ ಎಂದು ಕಾಣಿಸುತ್ತದೆ.

682
00:43:44,620 --> 00:43:47,500

683
00:43:47,500 --> 00:43:57,230
ಅದಕ್ಕೆ ಜೊತೆಯಾಗಿ, ನ ರಚಿಸಲು ಅವಕಾಶ
runMario ಎಂಬ ಮತ್ತೊಂದು ವಿಧಾನ.

684
00:43:57,230 --> 00:44:00,140

685
00:44:00,140 --> 00:44:03,436
ಓಹ್ ಕ್ಷಮಿಸಿ, ಒಂದು ಆಸ್ತಿ ಮಾಡಬಾರದು.

686
00:44:03,436 --> 00:44:12,107

687
00:44:12,107 --> 00:44:13,940
ಸರಿ, ಎಂದು ಮಾಡಬೇಕಾದುದು
ಹಾಗೂ ಕ್ರಿಯಾಶೀಲ.

688
00:44:13,940 --> 00:44:25,780

689
00:44:25,780 --> 00:44:34,740
>> ಮತ್ತು ಕಾರ್ಯ ಯಾವಾಗ
ಎಂಬ, ನಾವು ಮಾರಿಯೋ ಹತ್ತು ರನ್.

690
00:44:34,740 --> 00:44:37,620

691
00:44:37,620 --> 00:44:39,780
ಆಶಾದಾಯಕವಾಗಿ ಉತ್ತಮವಾಗಿರುತ್ತವೆ.

692
00:44:39,780 --> 00:44:41,120
ಇದು ಕಂಪೈಲ್ ಮಾಡುವುದಿಲ್ಲ?

693
00:44:41,120 --> 00:44:43,920
ಹೌದು.

694
00:44:43,920 --> 00:44:45,090
ಈಗ ನಾವು ಒಂದು ನೋಟ ಪಡೆಯಲು.

695
00:44:45,090 --> 00:44:46,560
ನಾವು ಒಂದು ಉತ್ಪಾದನೆಯನ್ನು.

696
00:44:46,560 --> 00:44:50,040
ಮತ್ತು ಕೇವಲ ಏನಾಗುತ್ತದೆ ನೋಡೋಣ.

697
00:44:50,040 --> 00:44:52,590
ಆ ಗಾನ್.

698
00:44:52,590 --> 00:44:54,500
ಇದು ಮತ್ತೆ ಇಲ್ಲಿದೆ.

699
00:44:54,500 --> 00:44:57,620
ಇಲ್ಲಿ ನಾವು ವಿಶ್ಲೇಷಿಸಿದ
ಕಾರ್ಯ ಯಾವ ರೀತಿಯ

700
00:44:57,620 --> 00:45:00,400
ಯಾವಾಗ ಕರೆಯಬಹುದು
ನಾವು ಏನೋ ಟೈಪ್,

701
00:45:00,400 --> 00:45:03,160
ನಾವು ಒಂದು ನಿರ್ದಿಷ್ಟ ಗುಂಡಿಯನ್ನು ಒತ್ತಿ.

702
00:45:03,160 --> 00:45:07,890
ಈ ಮೂಲತಃ
ಗುರಿ ಕ್ರಮ ಯೋಜನೆ

703
00:45:07,890 --> 00:45:12,510
ಕಾರ್ಯಕ್ರಮಕ್ಕಾಗಿ ನಡೆಸುತ್ತಿದೆ
ಉದ್ದೇಶ ಸಿ ಕಾರ್ಯಕ್ರಮಗಳನ್ನು

704
00:45:12,510 --> 00:45:15,030
>> ಅದಕ್ಕೆ ಜೊತೆಯಾಗಿ,
ಇದು ತುಂಬಾ ಉತ್ತೇಜನಕಾರಿಯಾಗಿದೆ ಅಲ್ಲ

705
00:45:15,030 --> 00:45:19,810
ನಾವು ಬದಲಾಯಿಸಲು ಸಾಧ್ಯವಿಲ್ಲ ಏಕೆಂದರೆ
ಪಿರಮಿಡ್ ಹೇಗೆ ಹೆಚ್ಚು ಇರುತ್ತದೆ,

706
00:45:19,810 --> 00:45:23,640
ಆದ್ದರಿಂದ ನಾವು ಬಹುಶಃ ಹೇಗಾದರೂ ಬಯಸುವ
ಬಳಕೆದಾರರಿಂದ ಇನ್ಪುಟ್ ಪಡೆಯಲು

707
00:45:23,640 --> 00:45:29,490
ಮತ್ತು ಎತ್ತರವನ್ನು ಬದಲಾಯಿಸಲು
ಪಿರಮಿಡ್ ಅವರು ಔಟ್ಪುಟ್ ಆಧರಿಸಿ.

708
00:45:29,490 --> 00:45:32,900
ಆದ್ದರಿಂದ ನಾವು ಮಾಡಲು ನೀನು.

709
00:45:32,900 --> 00:45:38,720
ನಾವು runMario ಕರೆ ಮಾಡಿದಾಗ ಈ ಬಾರಿ,
ನಾವು ಮಾರಿಯೋ ನೇರವಾಗಿ ಕರೆ ಮಾಡಬೇಡಿ.

710
00:45:38,720 --> 00:46:06,280

711
00:46:06,280 --> 00:46:07,000
ಈ ಒಂದು ಶೀರ್ಷಿಕೆ.

712
00:46:07,000 --> 00:46:22,180

713
00:46:22,180 --> 00:46:23,700
>> ಪ್ರತಿನಿಧಿ.

714
00:46:23,700 --> 00:46:25,160
ಈ ಕುತೂಹಲಕಾರಿ ಆಗಿದೆ.

715
00:46:25,160 --> 00:46:26,720
ಪ್ರತಿನಿಧಿಯಾಗಿ ಏನು?

716
00:46:26,720 --> 00:46:28,950
ನಾನು ಇಲ್ಲಿ ಸ್ವಯಂ ಹಾಕಲು ಪಡೆಯಲಿದ್ದೇನೆ.

717
00:46:28,950 --> 00:46:31,038
ಮತ್ತು ನಾವು ನೋಡಲು ನೀನು
ಏನು ನಂತರ ಅರ್ಥ.

718
00:46:31,038 --> 00:46:46,380

719
00:46:46,380 --> 00:46:51,120
ಇಲ್ಲಿ ನಾವು ಮೂಲಭೂತವಾಗಿ ರಚಿಸಿದ ಒಂದು
ನಿರ್ದಿಷ್ಟ ಉದಾಹರಣೆಗೆ ಒಂದು UI ಎಚ್ಚರಿಕೆಯನ್ನು ಎಂದು

720
00:46:51,120 --> 00:46:52,210
ವೀಕ್ಷಿಸಿ.

721
00:46:52,210 --> 00:46:54,440
ಒಂದು UI ಎಚ್ಚರಿಕೆಯನ್ನು ಚಿತ್ರಣವಾಗಿದೆ
ಮೂಲತಃ ನೀವು ಯಾವ

722
00:46:54,440 --> 00:46:58,940
ಪ್ರತಿ ಬಾರಿ ಏನಾದರೂ ಪಾಪ್ಸ್ ನೋಡಿ
ಇನ್ಪುಟ್ ನೀವು ಕೇಳುತ್ತದೆ ಮತ್ತು,

723
00:46:58,940 --> 00:47:03,080
ನೀವು ಪ್ರಯತ್ನಿಸುತ್ತಿರುವ ಏನಾಗುವುದೆಂದು ಹಾಗೆ
ಒಂದು ಅಪ್ಲಿಕೇಶನ್ ಸ್ಟೋರ್ನಲ್ಲಿ ಏನೋ ಖರೀದಿಸಲು.

724
00:47:03,080 --> 00:47:14,250
>> ಅದಕ್ಕೆ ಜೊತೆಯಾಗಿ, ನೀವು ನಂತರ
ಇದು ರಚಿಸಲು, ನಾವು ಎಚ್ಚರಿಕೆಯನ್ನು ತೋರಿಸಲು.

725
00:47:14,250 --> 00:47:20,090

726
00:47:20,090 --> 00:47:22,568
ಸರಿ, ಕೇವಲ ತ್ವರಿತವಾಗಿ ಹೊರಡೋಣ
ಪರೀಕ್ಷಾ ಕೆಲಸ ಅಥವಾ ತಿನ್ನುವೆ.

727
00:47:22,568 --> 00:47:31,105

728
00:47:31,105 --> 00:47:32,140
ಬಹಳ ತಂಪಾದ ಇಲ್ಲಿದೆ.

729
00:47:32,140 --> 00:47:55,370

730
00:47:55,370 --> 00:47:59,120
ಈಗ ನಿಜವಾಗಿಯೂ ಒಂದು ರಚಿಸಲು ಅವಕಾಶ
ಯುಐ ಎಚ್ಚರಿಕೆಯನ್ನು ಇನ್ಪುಟ್ ಕ್ಷೇತ್ರದಲ್ಲಿ.

731
00:47:59,120 --> 00:48:01,170
ಈ ನಾವು ಹೇಗೆ.

732
00:48:01,170 --> 00:48:07,490
ಮತ್ತು ನಾವು ಒಂದು ಇರಬೇಕು
ಎಚ್ಚರಿಕೆಯನ್ನು ಇನ್ಪುಟ್ ವೀಕ್ಷಿಸಿ.

733
00:48:07,490 --> 00:48:09,020
ತುಂಬಾ ತಂಪು.

734
00:48:09,020 --> 00:48:12,330
ಕೇವಲ 10 ಹೇಳುತ್ತಾರೆ.

735
00:48:12,330 --> 00:48:14,900
>> ಇದು ಬಲ ಏನು ಮಾಡುವುದರಿಂದ ದೊರೆಯದಿದ್ದಲ್ಲಿ
ಈಗ ಕರೆ ವಾಸ್ತವವಾಗಿ ಏಕೆಂದರೆ

736
00:48:14,900 --> 00:48:17,770
ಮಾರಿಯೋ ಪಾಲಿಸಲು ಬದಲಾಗಲಿಲ್ಲ.

737
00:48:17,770 --> 00:48:23,470
ಆದ್ದರಿಂದ ಈ ಸ್ವಲ್ಪ ಮಾರ್ಪಟ್ಟಿದೆ
ಸ್ವಲ್ಪ ವಿಯರ್ಡ್ ಬಂದ ಕಾರಣ

738
00:48:23,470 --> 00:48:30,790
ನಾವು, ಬಂದ ನಾವು ಕೆಳಗೆ ಒಂದು ಬಟನ್ ಒತ್ತಿ
ಎಚ್ಚರಿಕೆಯನ್ನು ದೃಷ್ಟಿಯಲ್ಲಿ ಒಂದು ಬಟನ್ ಒತ್ತಿ,

739
00:48:30,790 --> 00:48:35,560
ಏನೋ, ಆಗಬೇಕಿರುವುದೇನು
ಆದರೆ ಇದು ನಡೆಯುತ್ತಿಲ್ಲ.

740
00:48:35,560 --> 00:48:37,220
ನಾವು ಹೇಗೆ ಕ್ಯಾಚ್ ಇಲ್ಲ?

741
00:48:37,220 --> 00:48:41,280
ಹೇಗೆ ನಾವು ಒಂದು ಬಳಕೆದಾರ ತಿಳಿದಿದೆ
ಎಚ್ಚರಿಕೆಯನ್ನು ವೀಕ್ಷಿಸಿ ತಳ್ಳಿಹಾಕಿದರು

742
00:48:41,280 --> 00:48:45,630
ಮತ್ತು ಈಗಾಗಲೇ, ಅನೇಕ ಪ್ರವೇಶಿಸಿತು
ಇದೀಗ ಏನೂ ನಿಜವಾಗಿ ಏನು ನಡೆಯುತ್ತಿದೆ.

743
00:48:45,630 --> 00:48:50,450
>> ಅಲ್ಲದೆ, ನೀವು ಊಹಿಸಿದ ಎಂಬುದರಲ್ಲಿ
ಇದು ಬಲ, ನಿಯೋಗ.

744
00:48:50,450 --> 00:48:55,440
ಆದ್ದರಿಂದ ಎಲ್ಲಾ ಜೊತೆಗೆ
ಈ ಘೋಷಣೆಗಳು,

745
00:48:55,440 --> 00:49:03,190
ನಾವು ಹೊಸ ನಿಯೋಗ ಸೇರಿಸುವ ಅಗತ್ಯವಿದೆ
ಇದು UI ಎಚ್ಚರಿಕೆಯನ್ನು ವೀಕ್ಷಿಸಿ ಪ್ರತಿನಿಧಿ ಎಂಬ.

746
00:49:03,190 --> 00:49:06,440
ಪ್ರತಿಯೊಂದು ಆದ್ದರಿಂದ
ಪರಸ್ಪರ ಅಥವಾ ಈವೆಂಟ್

747
00:49:06,440 --> 00:49:10,190
ನಾವು ನೀನು
ಯುಐ ಎಚ್ಚರಿಕೆಯನ್ನು ದೃಷ್ಟಿಯಿಂದ

748
00:49:10,190 --> 00:49:14,100
ನಿರ್ವಹಿಸಬಹುದಾದ ಹೋಗುತ್ತದೆ
ಜೊತೆಗೆ ನಮ್ಮ ವರ್ಗ ಮೂಲಕ.

749
00:49:14,100 --> 00:49:26,297
>> ಆದ್ದರಿಂದ ಜೊತೆಗೆ, ಎಂದು ಕಾಣಿಸುತ್ತದೆ
ಇಂಡೆಕ್ಸ್ನಲ್ಲಿ ಎಚ್ಚರಿಕೆಯನ್ನು ವೀಕ್ಷಿಸಿ ಕ್ಲಿಕ್ ಬಟನ್.

750
00:49:26,297 --> 00:49:34,260

751
00:49:34,260 --> 00:49:37,730
ಈ ತಲುಪಿದಾಗ.

752
00:49:37,730 --> 00:49:42,020
ನಾವು ಹೊಂದಿರುವ ಸಂದರ್ಭದಲ್ಲಿ
ಈಗಾಗಲೇ ನಾವು ಹೊಂದಿವೆ

753
00:49:42,020 --> 00:49:46,210
ಒಂದು ಪ್ರೋಟೋಕಾಲ್ ಪತ್ತೆಹಚ್ಚಿದರು
ಕ್ರಿಯೆಯನ್ನು ನಿರ್ವಹಿಸಲಿದೆ

754
00:49:46,210 --> 00:49:51,320
ನಾವು ಮಾಡಿದ ಗುಂಡಿಯನ್ನು ಕ್ಲಿಕ್
ಎಚ್ಚರಿಕೆಯನ್ನು ವೀಕ್ಷಣೆಯನ್ನು.

755
00:49:51,320 --> 00:49:55,976
ಆದ್ದರಿಂದ ಪ್ರತಿ ಬಾರಿ ನಾವು ಔಟ್
ಎಚ್ಚರಿಕೆಯನ್ನು ವೀಕ್ಷಿಸಿ, ಈ ಆಗಬೇಕಿರುವುದೇನು.

756
00:49:55,976 --> 00:49:57,350
ನನಗೆ ಬೇಗನೆ ಪರೀಕ್ಷಿಸೋಣ.

757
00:49:57,350 --> 00:50:16,220

758
00:50:16,220 --> 00:50:19,300
ಸರಿ ವಾಸ್ತವವಾಗಿ, ನಾವು ಇಲ್ಲಿ ತಲುಪಿದ್ದೀರಿ.

759
00:50:19,300 --> 00:50:22,210
>> ಇಲ್ಲಿ, ನಾವು ತಿನ್ನುವೆ
ವಾಸ್ತವವಾಗಿ ವಾಸ್ತವವಾಗಿ ಪಡೆಯಲು

760
00:50:22,210 --> 00:50:43,120
ನಾವು ಹೊರಗೆ ಪಡೆಯಲು ಬಯಸುವ ಮುಚ್ಚಲಿದೆ ಪಡೆಯಲು
ನಾವು ಹಿಂದೆ ಎಂದು ಪಠ್ಯ

761
00:50:43,120 --> 00:50:45,350
ಎಚ್ಚರಿಕೆಯನ್ನು ವೀಕ್ಷಣೆಯಲ್ಲಿ ಪ್ರವೇಶಿಸಿತು.

762
00:50:45,350 --> 00:50:48,505
ಮತ್ತು ಪಠ್ಯ ಆಧರಿಸಿ, ನಾವು ಆರ್
ಮಾರಿಯೋ ಪ್ರದರ್ಶಿಸಲು ಹೋಗಿ.

763
00:50:48,505 --> 00:50:52,336

764
00:50:52,336 --> 00:50:55,480
ಈ ಬೇಗನೆ ಔಟ್ ತಿರುಗುತ್ತದೆ
ಇದು ವಾಸ್ತವವಾಗಿ ಕೆಲಸ ಅಥವಾ ಅಲ್ಲ.

765
00:50:55,480 --> 00:50:59,476
ಆ ಸಂದರ್ಭದಲ್ಲಿ, ನಾವು ಇನ್ಪುಟ್ ವೇಳೆ,
ನಾವು 10 ನೋಡಿ, 10, ಸೇ.

766
00:50:59,476 --> 00:51:02,740

767
00:51:02,740 --> 00:51:05,210
>> ಉತ್ತಮ, ನಾವು ಇಲ್ಲಿ ಹೊಂದಿರುತ್ತವೆ.

768
00:51:05,210 --> 00:51:06,470
ಇದು ಬಹಳ ಒಳ್ಳೆಯದು.

769
00:51:06,470 --> 00:51:16,840
ಈಗ ಕೊನೆಯ ಹಂತದ ಆದ್ದರಿಂದ ಎಷ್ಟೊಂದು ಕಾಣಿಸುತ್ತದೆ
ಕೊನೆಯ ಹಂತದ ಇದೀಗ ಮಾಡಬೇಕಾದ್ದು

770
00:51:16,840 --> 00:51:21,100
ಕೇವಲ ಒಂದು ಜೊತೆ ಮಾರಿಯೋ ಕರೆ ಇದೆ
ಮಟ್ಟದ ಇನ್ಪುಟ್ ಆಧಾರದ ಮೇರೆಗೆ

771
00:51:21,100 --> 00:51:23,270
ನಾವು ಎಚ್ಚರಿಕೆಯನ್ನು ವೀಕ್ಷಣೆಗೆ ಹಾಕಬಹುದು.

772
00:51:23,270 --> 00:51:26,920
ನಾವು ಪರಿವರ್ತಿಸುವ ಅಗತ್ಯವಿದೆ
ಐಒಎಸ್ ಈ ಸ್ಟ್ರಿಂಗ್.

773
00:51:26,920 --> 00:51:33,820

774
00:51:33,820 --> 00:51:35,496
ಸ್ಥಿರ ಸ್ಥಳಾಂತರವನ್ನು ಬಹಳ ಆಕರ್ಷಕವಾಗಿದೆ.

775
00:51:35,496 --> 00:51:44,930

776
00:51:44,930 --> 00:51:51,182
ನಂತರ ನಾವು ಸ್ವಯಂ ಕರೆ
marioWithLevels ಮೌಲ್ಯವನ್ನು.

777
00:51:51,182 --> 00:51:54,550

778
00:51:54,550 --> 00:51:56,284
ನ ತಿನ್ನುವೆ ನೋಡೋಣ
ವಾಸ್ತವವಾಗಿ ಕೆಲಸ ಅಥವಾ.

779
00:51:56,284 --> 00:51:59,070

780
00:51:59,070 --> 00:52:01,550
>> ನಾವು ಈಗಾಗಲೇ ಒಂದು ಪಿರಮಿಡ್ ನೀಡಿದ ನೀವು.

781
00:52:01,550 --> 00:52:04,785
ಎತ್ತರ ಬದಲಾಯಿಸಲು ಪ್ರಯತ್ನಿಸೋಣ.

782
00:52:04,785 --> 00:52:06,530
ವಾಸ್ತವವಾಗಿ ಕೆಲಸ.

783
00:52:06,530 --> 00:52:07,610
ಇದು ತುಂಬಾ ಸುಂದರವಾಗಿದೆ ಇಲ್ಲಿದೆ.

784
00:52:07,610 --> 00:52:10,420
ಈಗ ನೀವು ಕೇವಲ
ಇನ್ಪುಟ್ ನೀವು ಯಾವುದೇ ಮೌಲ್ಯವನ್ನು.

785
00:52:10,420 --> 00:52:12,440
ಕೇವಲ ನಾಲ್ಕು ಹೇಳುತ್ತಾರೆ.

786
00:52:12,440 --> 00:52:14,260
ಬಹಳ ಉತ್ತಮವಾಗಿದೆ.

787
00:52:14,260 --> 00:52:17,090
ಆದ್ದರಿಂದ ಈ ಮೂಲತಃ
ನಿಜವಾಗಿಯೂ ತ್ವರಿತ ಉದಾಹರಣೆಗೆ

788
00:52:17,090 --> 00:52:23,170
ರು ಕೋಡ್ ಒಂದು ಯೋಜನೆಯನ್ನು ರಚಿಸಿ ಹೇಗೆ
ಮತ್ತು ನಿಜವಾಗಿಯೂ ವೇಗವಾಗಿ ಅಪ್ WIRE ಹೇಗೆ

789
00:52:23,170 --> 00:52:26,220
ಕೆಲವು ನಿಜವಾಗಿಯೂ ಸರಳ ಕಾರ್ಯಕ್ರಮಗಳಲ್ಲೂ.

790
00:52:26,220 --> 00:52:28,840
>> ಆದ್ದರಿಂದ ಮೂಲ ಹೋಗುತ್ತದೆ
ನಂತರ ಆನ್ಲೈನ್ ಪುಟ್.

791
00:52:28,840 --> 00:52:33,400
ನೀವು ನಿಮಗೆ ಆಸಕ್ತಿ ಇದ್ದರೆ ಆದ್ದರಿಂದ
ಐಒಎಸ್ ಮಾರಿಯೋ ಕೆಲಸ ಹೇಗೆ,

792
00:52:33,400 --> 00:52:38,360
ನಾನು ಒಂದೇ ಹಾಕಲು ಪಡೆಯಲಿದ್ದೇನೆ
ನಂತರ CS50 ವೆಬ್ಸೈಟ್ ಮೇಲೆ ಯೋಜನೆಗಳು.

793
00:52:38,360 --> 00:52:41,260
ನಾವು ಮೂಲತಃ ಪೂರೈಸಿದ
ಬೇಸಿಗೆಯಲ್ಲಿ, ನಾವು ಮತ್ತು ಮುಗಿಸಲು ಮೊದಲು

794
00:52:41,260 --> 00:52:45,190
ನಾನು ನೀವು ಹುಡುಗರಿಗೆ ತೋರಿಸಲು ಬಯಸುವ
ಕೆಲವು ನಿಜವಾಗಿಯೂ ನಿಜಕ್ಕೂ ಸಂಪನ್ಮೂಲಗಳನ್ನು

795
00:52:45,190 --> 00:52:47,550
ಆನ್ಲೈನ್ ಲಭ್ಯವಿದೆ.

796
00:52:47,550 --> 00:52:52,270
>> ನಿಸ್ಸಂಶಯವಾಗಿ ಆಪಲ್ ದಸ್ತಾವೇಜನ್ನು
ತುಂಬಾ ಉಪಯುಕ್ತ ಎಂದು ಹೋಗುತ್ತದೆ.

797
00:52:52,270 --> 00:52:57,630
ಆದರೆ ಜೊತೆಗೆ, ನಾನು ವಿಶೇಷವಾಗಿ
ನಾಲ್ಕು ಮೂಲಗಳು, ಕೋಡ್ ಶಾಲೆಯ ಶಿಫಾರಸು

798
00:52:57,630 --> 00:53:02,120
ಮರದ ಮನೆ, AppCoda ಮತ್ತು ಡಬ್ಲುಡಬ್ಲುಡಿಸಿ ವೀಡಿಯೊಗಳನ್ನು.

799
00:53:02,120 --> 00:53:07,270
ಕೋಡ್ ಶಾಲೆಯ ಮತ್ತು ಮರದ ಮನೆ
ಎರಡು ಆನ್ಲೈನ್ ಶಿಕ್ಷಣ ವೆಬ್ಸೈಟ್,

800
00:53:07,270 --> 00:53:10,210
ಇದು ಗಮನಹರಿಸಲು
ಸಾಫ್ಟ್ವೇರ್ ಎಂಜಿನಿಯರಿಂಗ್.

801
00:53:10,210 --> 00:53:16,930
ವಿಶೇಷವಾಗಿ ಕೋಡ್ ಶಾಲೆ, ಅವರು
ಐಒಎಸ್ ಒಳ್ಳೆಯ ಟ್ಯುಟೋರಿಯಲ್ ಹೊಂದಿವೆ.

802
00:53:16,930 --> 00:53:19,550
>> ಅದು ಒಂದು ನಿಜವಾಗಿಯೂ ತ್ವರಿತ ಉದಾಹರಣೆ.

803
00:53:19,550 --> 00:53:22,980
ಅವರು ವಾಸ್ತವವಾಗಿ ನಿಜವಾಗಿಯೂ cute-- ರಚಿಸಲು
ಆ ಪುಟ್ಟ ಮುದ್ದಾದ ಐಫೋನ್ ನೋಡಲು

804
00:53:22,980 --> 00:53:24,920
ಅಲ್ಲಿರುವ ಸೊಗಸುಗಾರ, ಇದು ಬಹಳ ಉತ್ತಮವಾಗಿದೆ.

805
00:53:24,920 --> 00:53:31,010
ಮತ್ತು ರೀತಿಯಲ್ಲಿ ಅವರು ಉದ್ದೇಶ ವಿವರಿಸಲು
ಸಿ ವಾಕ್ಯ ನಿಖರವಾಗಿ ಸ್ಪಷ್ಟವಾಗಿದೆ.

806
00:53:31,010 --> 00:53:32,230
ಮರದ ಮನೆ ಒಂದೇ.

807
00:53:32,230 --> 00:53:34,660
ಮತ್ತು AppCoda ವೇದಿಕೆ ಇದು.

808
00:53:34,660 --> 00:53:38,130
ನಿಜವಾಗಿ ಔಟ್ ಎಂದು ಒಂದು ಬ್ಲಾಗ್
ನಿಜವಾಗಿಯೂ ಅನುಭವ ಉದ್ದೇಶ ಸಿ ಮೂಲಕ

809
00:53:38,130 --> 00:53:39,120
ಪ್ರೋಗ್ರಾಮರ್.

810
00:53:39,120 --> 00:53:43,950
ಮತ್ತು AppCoda ಎಲ್ಲ ಆ ಟ್ಯುಟೋರಿಯಲ್ ಇವೆ
ಬಹಳ ಸಣ್ಣ ಮತ್ತು ಅಳವಡಿಸಲು ಸುಲಭ,

811
00:53:43,950 --> 00:53:45,390
ಹೆಚ್ಚು ಶಿಫಾರಸು.

812
00:53:45,390 --> 00:53:47,700
>> ಮತ್ತು ನೀವು ಡೆವಲಪರ್ ವೇಳೆ,
ಖಂಡಿತವಾಗಿ ಪರಿಶೀಲಿಸಿ ಹೋಗಿ

813
00:53:47,700 --> 00:53:55,660
ಹೇಗೆ ಡಬ್ಲುಡಬ್ಲುಡಿಸಿ ವೀಡಿಯೊಗಳನ್ನು ಅಲ್ಲಿ ನೀವು
ಇತ್ತೀಚಿನ ಐಒಎಸ್ ಪ್ರೋಗ್ರಾಮಿಂಗ್ ಬಗ್ಗೆ ತಿಳಿಯಲು

814
00:53:55,660 --> 00:53:58,250
ತಂತ್ರಗಳನ್ನು, API ಗಳು ಮತ್ತು ಗ್ರಂಥಾಲಯಗಳು.

815
00:53:58,250 --> 00:54:02,850
ಆದ್ದರಿಂದ ಬಹುಮಟ್ಟಿಗೆ
ಸೆಮಿನಾರ್ ಇದು.

816
00:54:02,850 --> 00:54:03,820
ತುಂಬಾ ಧನ್ಯವಾದಗಳು.

817
00:54:03,820 --> 00:54:08,040
ಮತ್ತು ನಾನು ನೀವು ಆನಂದಿಸಿ ಆಶಿಸುತ್ತೇವೆ
ನಿಮ್ಮ ಸ್ವಂತ ಐಒಎಸ್ ಅಪ್ಲಿಕೇಶನ್ ರಚಿಸಲು.

818
00:54:08,040 --> 00:54:09,302