Baby Monitor Timmy ఒక సులభమైన ఆలోచనతో మొదలైంది: ఇంట్లో గోప్యతను గౌరవించే బేబీ మానిటర్. క్లౌడ్ రికార్డింగ్లు లేవు, పిల్లల గది నుంచి బయటకు వెళ్లే అనవసర డేటా మార్గాలు లేవు. చాలామందికి కనిపించని విషయం ఏమిటంటే: జ్యూరిఖ్లో Timmyని నేను ఒక్కడినే రూపొందిస్తున్నాను, మరియు GitHub Copilot నా చాలా వేగవంతమైన పెయిర్ ప్రోగ్రామర్.
మనిషి-AI పని విధానం
పనుల విభజన స్పష్టంగా ఉంటుంది: ఫీచర్లను నేను నిర్ణయిస్తాను, ప్రాధాన్యతలు పెడతాను, ఆర్కిటెక్చర్ నిర్ణయాలు తీసుకుంటాను. అమలులో Copilot సహాయం చేస్తుంది: కోడ్ రాయడం, టెస్టులు జోడించడం, బగ్ల కారణాలను గుర్తించడం, విడుదల దశలను సిద్ధం చేయడం.
నా దగ్గర ఒక సాధారణ స్ప్రింట్ సుమారుగా ఇలా ఉంటుంది:
- ఫీచర్ వివరణ: ఎడ్జ్ కేసులు, పరిమితులతో సహా ఆ ఫీచర్ ఏమి చేయాలో నేను వివరిస్తాను.
- అమలు: Copilot కోడ్ను సూచిస్తుంది, ప్రాజెక్ట్లో ఇప్పటికే ఉన్న నియమాలను అనుసరిస్తుంది.
- పరీక్షలు: రెండు ఎమ్యులేటర్లపై ఆటోమేటెడ్ ఎండ్-టు-ఎండ్ పరీక్షలు నడిచి, అసలు బేబీ/పేరెంట్ కనెక్షన్ను తనిఖీ చేస్తాయి.
- పంపిణీ: పరీక్షలు విజయవంతమైతే, సరైన స్టోర్లు, టెస్టింగ్ ట్రాక్ల కోసం Android మరియు iOS బిల్డ్లు సిద్ధమవుతాయి.
ఫీచర్లు, బగ్ పరిష్కారాల కోసం ఈ చక్రం పునరావృతమవుతుంది. ప్రతి పంక్తి కోడ్ను నేను స్వయంగా రాయను, కానీ ఏది రూపొందించాలి, ఎందుకు దాన్ని రూపొందించాలి, అలాగే ఒక సూచన Timmyకి సరిపోతుందా లేదా అనేది నేను నిర్ణయిస్తాను.
ఆలోచన నుంచి WebRTC వరకు
ప్రధాన సాంకేతిక పని మొదటి నుంచే స్పష్టంగా ఉంది: రెండు ఫోన్ల మధ్య రియల్-టైమ్ ఆడియో, వీడియో. WebRTC సహజమైన ఎంపికే, కానీ దాన్ని Flutterతో అనుసంధానించడం అంత సులభం కాదు: ICE candidates, SDP negotiation, TURN fallback, DataChannels అన్నీ సరైన క్రమంలో కలిసి పని చేయాలి.
ఆ భాగాలన్నింటినీ దశలవారీగా కలపడంలో Copilot నాకు తోడ్పడింది: peer connectionను ఏర్పాటు చేయడం, కీలక క్రమాన్ని సరిగా ఉంచడం (offer కంటే ముందు DataChannel, setRemoteDescription కంటే ముందు onTrack), అలాగే signalingను Firebase Firestoreలో ఉంచడం. ముందుకు వెళ్లే ముందు ప్రతి భాగం రెండు ఎమ్యులేటర్లలో నడవాల్సి వచ్చేది.
ECDHతో సురక్షిత జతచేయడం
అత్యంత కీలకమైన ఫీచర్లలో ఒకటి సురక్షిత జతచేయు వ్యవస్థ. రెండు పరికరాలు తమ గుర్తింపుకు హామీ ఇచ్చే కేంద్ర సర్వర్పై ఆధారపడకుండా పరస్పర విశ్వాసాన్ని ఏర్పరచుకోవాలి. పరిష్కారం: Firebase ద్వారా ECDH P-256 కీ మార్పిడి, man-in-the-middle దాడులను గుర్తించే విజువల్ వెరిఫికేషన్ నంబర్ (SAS)తో కలిపి.
క్రిప్టోగ్రాఫిక్ గొలుసును అమలు చేయడంలో Copilot సహాయపడింది: కీ రూపొందించడం, పబ్లిక్ కీ మార్పిడి, షేర్డ్ సీక్రెట్ను పొందడం, SAS లెక్కించడం, తర్వాతి signaling డేటా మొత్తానికి AES-256-GCM ఎన్క్రిప్షన్. నేను pairing keyని బ్యాకెండ్కు పంపను; దాని SHA-256 హ్యాష్ మాత్రమే Firestore డాక్యుమెంట్ ఐడెంటిఫైయర్గా వాడబడుతుంది.
భద్రతా ఆడిట్: లోపాలను గుర్తించి సరిచేయడం
AI-సహాయంతో అభివృద్ధి అంటే నాకు కేవలం వేగంగా టైప్ చేయడం కాదు. పద్ధతిగా బగ్లను వెతకడంలో కూడా ఇది ఉపయోగపడుతుంది. కేంద్రీకృత భద్రతా ఆడిట్ స్ప్రింట్లో Copilot కోడ్బేస్ను విశ్లేషించి ఆరు సమస్యలను గుర్తించింది; వాటిని నేను సరిచేయాల్సి వచ్చింది:
- signaling డేటాకు ఇన్పుట్ ధ్రువీకరణ లేకపోవడం
- ICE candidate నిర్వహణలో సంభవించే race conditions
- సరిగా తొలగించబడని పాత session డేటా
- మరీ సడలింపుగా ఉన్న Firestore భద్రతా నియమాలు
- certificate pinningకు సంబంధించిన అంశాలు పరిగణనలో లేకపోవడం
- TURN credential ప్రక్రియలో తగిన error handling లేకపోవడం
ఆ ఆరింటినీ అదే స్ప్రింట్లో సరిచేశాం. ఇక్కడే Copilot బలంగా ఉంటుంది: అనేక ఫైల్లను చదవడం, నమూనాలను పోల్చడం, నేను మరింత జాగ్రత్తగా పరిశీలించాల్సిన చోట్లను గుర్తించడం.
పునరావృత స్ప్రింట్లు: యాప్ ఎలా అభివృద్ధి చెందింది
Timmy వేగవంతమైన, కానీ స్పష్టమైన హద్దులు ఉన్న స్ప్రింట్ల ద్వారా పెరిగింది. కొన్ని ముఖ్య ఘట్టాలు:
- v1.8: జతచేయడం పూర్తిగా పునర్నిర్మాణం — Firebase ద్వారా 4-అక్షరాల కోడ్ + ECDH P-256 పాత డైరెక్ట్-కీ విధానాన్ని భర్తీ చేసింది.
- v1.10: భద్రతా బలోపేతం స్ప్రింట్ — ఆరు లోపాల ఆడిట్, పరిష్కార చక్రం.
- v1.11: అన్ని స్క్రీన్లలో డార్క్ మోడ్, అలాగే మీరు ఇప్పుడే చదువుతున్న హోమ్పేజీ, బ్లాగ్.
- v1.12: పేరెంట్ స్క్రీన్లో పెద్ద మార్పు, నైట్ విజన్ మోడ్, కెమెరా ఫ్రేమ్ విశ్లేషణ ద్వారా కదలిక గుర్తింపు.
ప్రతి స్ప్రింట్ ఒకే ప్రాథమిక విధానాన్ని అనుసరిస్తుంది: లక్ష్యాన్ని వివరించడం, సూచనలను సమీక్షించడం, ఆటోమేటిక్గా పరీక్షించడం, తర్వాత టెస్టర్లకు పంపడం.
పరికరాల మధ్య E2E పరీక్షలు
బేబీ మానిటర్ను ఒకే పరికరంలో సరిగా పరీక్షించలేరు. నాకు ఒక బేబీ పరికరం, ఒక పేరెంట్ పరికరం అవసరం. ఈ ప్రాజెక్ట్ ఒకేసారి నడిచే రెండు Android ఎమ్యులేటర్లతో మొదలై, ఇప్పుడు ఆ ప్రక్రియకు లోకల్ iOS సిమ్యులేటర్, నిజమైన పరికర పరీక్షలను కూడా జోడించింది. ఆటోమేటెడ్ Android టెస్ట్ స్క్రిప్ట్ ఇప్పటికీ:
- రెండు ఎమ్యులేటర్లలో యాప్ను ఇన్స్టాల్ చేస్తుంది
- రెండు పరికరాల్లో జతచేసే ప్రక్రియను పూర్తి చేస్తుంది
- ఆడియో, వీడియో కనెక్షన్లు ఏర్పడ్డాయని ధ్రువీకరిస్తుంది
- push-to-talk, కెమెరా నియంత్రణ, ఇతర ఫీచర్లను పరీక్షిస్తుంది
రెండు ఎమ్యులేటర్లు ఒకే IP చిరునామాను పంచుకుంటాయి (10.0.2.15), ప్రత్యక్ష పీర్-టు-పీర్ కనెక్షన్ను STUN ద్వారా ఏర్పాటు చేయడం అసాధ్యం. ప్రతి టెస్ట్ రన్ తప్పనిసరిగా Cloudflare TURN రిలే ద్వారా వెళ్లాలి. ఇది కొంచెం ఇబ్బందికరమైనదే, కానీ ఉపయోగకరం కూడా: అత్యంత సంక్లిష్టమైన కనెక్షన్ మార్గాన్ని ప్రతిసారి పరీక్షిస్తారు.
నేను నేర్చుకున్నవి
AI పెయిర్ ప్రోగ్రామర్తో పూర్తి యాప్ను రూపొందించడం నాకు కొన్ని విషయాలు నేర్పింది:
- ఆర్కిటెక్చర్ ఇప్పుడెన్నడూ లేనంత ముఖ్యమైనది. స్పష్టమైన నియమాలు, బాగా డాక్యుమెంట్ చేసిన కోడ్బేస్ AI స్థిరమైన కోడ్ను సూచించడానికి తోడ్పడతాయి. అస్పష్టత త్వరగా ఖరీదైనదిగా మారుతుంది.
- పరీక్షలు తప్పనిసరి. AI రూపొందించిన కోడ్కూ మనుషులు రాసిన కోడ్కు ఉండేంత కఠినమైన పరీక్షలు అవసరం. ఆటోమేటెడ్ E2E పరీక్షలు చేతితో పరీక్షిస్తే సులభంగా కనిపించకుండా పోయే సమస్యలను గుర్తించాయి.
- మనిషి ప్రక్రియలోనే ఉంటాడు. ప్రతి ఆర్కిటెక్చర్ నిర్ణయం, ప్రతి భద్రతా రాజీ, ప్రతి ఉత్పత్తి పరిమితి నాదే. AI అమలును వేగవంతం చేస్తుంది, కానీ నిర్ణయ సామర్థ్యాన్ని భర్తీ చేయదు.
- వేగం నాణ్యతకు అవకాశం ఇస్తుంది. ఫీచర్లు రోజుల బదులు గంటల్లో విడుదలవడం వల్ల, మెరుగుదల, బగ్ పరిష్కారాల కోసం మరిన్ని పునరావృతాలు మిగులుతాయి. వేగంగా ఉండటం అంటే స్వయంగా మంచిదని కాదు.
ముందు ఏముంది
Baby Monitor Timmy నిరంతరం అభివృద్ధి చెందుతోంది. iOS విడుదల దగ్గరలో ఉంది; దాని తర్వాత అదనపు సెన్సర్ ఫీచర్లు, నిరంతర భద్రతా బలోపేతం వస్తాయి. పని విధానం ఇలానే ఉంటుంది: దిశ, హద్దులను నేను నిర్ణయిస్తాను; Copilot త్వరగా అమలు చేయడంలో, తనిఖీ చేయడంలో సహాయపడుతుంది.
భద్రతకు సంబంధించిన బిల్డింగ్ బ్లాక్లు ఇప్పుడు స్పష్టమైన హద్దులలో పబ్లిక్ baby-monitor-timmy-core రిపోజిటరీలో. అక్కడే జతచేయడం, signaling, బ్యాకెండ్ ఇంటర్ఫేస్లకు సంబంధించిన ఆర్కిటెక్చర్ నిర్ణయాలు డాక్యుమెంట్ చేయబడ్డాయి.