Cookies op Tweakers

Tweakers maakt gebruik van cookies, onder andere om de website te analyseren, het gebruiksgemak te vergroten en advertenties te tonen. Door gebruik te maken van deze website, of door op 'Ga verder' te klikken, geef je toestemming voor het gebruik van cookies. Wil je meer informatie over cookies en hoe ze worden gebruikt, bekijk dan ons cookiebeleid.

Meer informatie

Door , , 133 reacties

Het onderzoeksinstituut van het Amerikaanse ministerie van Defensie, Darpa, stopt 11 miljoen dollar - omgerekend 9 miljoen euro - in een soort 'autocomplete' voor programmeurs. De software zou moeten inzien wat een programmeur wil bereiken en daarvoor relevante code invoegen.

De tool moet niet alleen tekst voorspellen, maar ook de concepten die in de code zijn uitgedrukt begrijpen om zo een voorspelling te kunnen doen. Daarbij moet eerder gebruikte code door de tool automatisch kunnen worden bijgeschaafd om te passen in de code die de programmeur al heeft getikt.

Om een voorspelling te kunnen doen, wil de Rice-universiteit die de tool ontwikkelt code indexeren die onder meer op Sourceforge of Github is opgeslagen, maar bedrijven zouden ook hun eigen closed-source-code als uitgangspunt kunnen nemen. Het project is dan ook Pliny gedoopt, naar Plinius de Oude, de maker van de eerst encyclopedie.

De tool zou ook beveiligingsproblemen en andere bugs in code moeten kunnen corrigeren. Een van de grote uitdagingen waar de makers van de tool mee te maken hebben is ervoor zorgen dat de gebruikte code van hoge kwaliteit is, zegt een van de onderzoekers tegen Wired. Ook de gebruikersvriendelijkheid is een uitdaging.

Moderatie-faq Wijzig weergave

Reacties (133)

Dit is een van de eerste dingen die uit gaat in mijn code editor, die feature haalt het bloed onder mijn nagels vandaan. Oh je hebt een if statement, dan zal ik er haakjes bij zetten. Ondertussen zit ik achter mijn scherm te ragen en kan ik het weer ongedaan maken.

Misschien doe ik het wel verkeerd, geen idee. Ik hoop dat als dit iets word het niet een betweterig stukje software word dat blokken code door je strot probeert te krijgen die je daarna weer op kunt gaan ruimen omdat ze je code hebben vernachelt.
Nou, ik vind het wel handig hoor. Wat kan je bijvoorbeeld met een if-statement zonder haakjes? Verder heb je shortcuts in Netbeans zoals "sout", en het programma typt dan voluit " System.out.println("") voor je, dat soort features vind ik juist wel handig.
In meerdere talen kan je if statements zonder haakjes gebruiken. Dan is het eerste statement na de if statement de statement die uitgevoerd wordt als aan de conditie voldaan wordt.

Zelf ben ik niet zo'n fan van de haakjes weglaten omdat het soms onduidelijkheden op kan leveren als hier bijvoorbeeld besproken wordt.

Over het concept van deze video. Natuurlijk zullen we naar steeds slimmere manieren gaan om te programmeren. En ik ben ook benieuwd waar dit heen leid. Het concept klinkt leuk, maar in hoeverre het nu haalbaar is weet ik niet. Dat is afwachten.
Hangt helemaal van de programmeertaal af. Ik werk zelf meestal in Ruby en daar is het best practise om dat soort syntactic sugar weg te laten. Moet ik uiteraard wel bij vermelden dat de taal daarvoor geoptimaliseerd is, wat je bijvoorbeeld in java niet hebt.
Inderdaad. IntelliJ (Netbeans wellicht ook?) suggereert ook standaard variabele en method namen (vaak meerdere), werkt super snel. Met drie of vier toetsaanslagen een hele methode stub neerzetten is gewoon super productief. Voorbeeld van jou ook, 4 aanslagen i.p.v. 22. :)

Hoe meer je bezig bent met de logica i.p.v. syntax en structuur, hoe beter wat mij betreft.
sout en fcom maak ik zelf ook veelvuldig gebruik van. ook trycatch is een mooi voorbeeld waarmee je in een keer een blokje kan maken waar je later logica in kan zetten. De structuur is er dan al en je hoeft alleen een (multi)catch te implementeren voor de exceptions die je verwacht.

Echter heb ik zelf een beetje een goedkope bijsmaak als we het hebben over de code templates. Na het invoeren van: "sout" + tab kan ik gelijk doortypen met de string die ik wil laten zien. echter bij sommige code templates is dat niet het geval. Dat is wel vrij vervelend, want hierdoor duurt het met controleren erbij net zolang als het daadwerkelijk snel uittypen met ctrl+spatie.
Een if-statement zonder haakjes is meer dat alleen de regel erna onder de if statement valt, alle regels na die regel zijn weer "gewone" code. Met haakjes valt alles in de haakjes onder de statement.

Shortcuts lijken me idd wel handig, geen idee of Komodo Edit daar iets mee kan...
Weet je goto fail nog? ;)
https://www.imperialviolet.org/2014/02/22/applebug.html

Overigens lijkt autocomplete voor concepten mij wel handig, maar je wil dan alsnog controleren of de gegenereerde code inderdaad klopt, wat je weer wat tijd kost. Alles valt en staat bij hoe goed de autocomplete werkt.

[Reactie gewijzigd door Heedless op 9 november 2014 12:35]

Is het nog steeds noodzakelijk om goto te gebruiken... Zijn er niet oplossingen daarvoor? Net als dat globale variabelen niet meer gebruikt hoeven te worden. Of denk ik te veel als een php programmeur hier?
Als PHP programmeur kan je sinds 5.3 ook goto gebruiken hoor ;)

http://php.net/manual/en/control-structures.goto.php
De richtlijnen zijn juist om het NIET te doen. Juist bij een high level programming language moet je dingen als goto vermijden. Dit was ook de reden dat ik benieuwd was waarom het bij C en C++ wel gebruikt word

Goto's zijn juist te vermijden met breaks,exits en recursive itterations

[Reactie gewijzigd door mikesmit op 9 november 2014 18:58]

Hoe vaak heb je een manual pagina gezien met bovenaan de pagina een cartoon die schreeuwt: "DOE DIT NIET!!!111"? Zelfs eval heeft "alleen maar" een blokje "caution: this is discouraged" eronder staan.

Ik heb werkelijk geen idee waarom ze dit in PHP gestopt hebben, en de mensen die de documentatie schrijven zo te zien ook niet. Misschien een uit de hand gelopen practical joke ("Hoe kunnen we PHP nog lekker maken en nog vervelender om te debuggen en auditen?" -> "Laten we support voor goto inbouwen!") die per ongeluk, door iemand die de grap niet snapte, uitgevoerd is?

Wie heeft trouwens bedacht dat Goto een "control structure" is? Het gebruiken van Goto is juist de meest effectieve manier om de structuur van je programma finaal kapot te maken (lees voor de grap de gedrochten onder "User Contributed Notes" als je niet snapt wat ik bedoel). |:(
Ja, je denkt teveel als PHP programmeur.
In C zijn er best een aantal situaties waarin je prima gebruik kunt maken van goto, bijvoorbeeld bij foutafhandeling op plekken waar je wel of niet al geheugen hebt gealloceerd.
Globale variabelen zijn ook niet per se slecht, maar het is makkelijk om er fouten mee te maken.

Maar het zijn beiden prima te gebruiken features voor geoptimaliseerde, low level code, die ervaren C programmeurs prima kunnen gebruiken.
Goto is zeker niet noodzakelijk, maar in dat geval vond iemand het wel de beste oplossing, waarschijnlijk uit snelheidsoogpunt. Het punt is alleen dat accolades (of curly braces of hoe je ze ook noemt) heel duidelijk aangeven wat wel en wat niet in een code block zit, zonder die dingen wordt het al snel minder overzichtelijk.
Dat is trouwens (nog verder off-topic) ook de reden dat ik heel erg fan ben geworden van dingen als Checkstyle (waar accolades e.d. kunnen worden afgedwongen) en Python (waar de visuele interpretatie gelijk is aan de syntactische interpretatie).
Dan moet je niet de autocompletion uitzetten, maar jouw code-standaarden instellen. Als je instellingen goed zijn werk je met autocompletion vťťl sneller dan zonder.

Om jouw voorbeeld om te draaien: ik vind het altijd irritant als ik in een simpele text-editor werk, en ik na een if-statement eerst een accolade sluiten moet toevoegen (twee regels lager, dat doe ik meteen zodat ik later niet met deze accolade in de knoop lig), en daarna weer een regel terug naar boven moet en dan handmatig een tab moet zetten om in te springen.
Ik zal eens spelen met de instellingen van Komodo in dat geval, maar volgens mij heeft die niet zo bijzonder veel instellingen voor dat soort dingen. Ik sta open voor suggesties voor betere editors (vooral voor PHP en web development) :)
Voor PHP en web development kan ik PHPStorm van JetBrains absoluut aanraden.

Echt een geweldige IDE, alleen niet gratis (wel voor studenten overigens)
Ik had versie 7 eens geprobeert maar het was niet echt mijn ding, vooral omdat hij geen aparte bestanden kon openen. Ik heb wel een open source licentie, zal versie 8 eens proberen.

Hopelijk kan ik er dingen als autocomplete wel genoeg instellen en hopelijk mis ik ook niets van Komodo.
Niet gratis, maar zeker wel goed betaalbaar en ook gratis voor open source projecten.
Ik kan de deze niet boven netbeans kiezen. Hetzelfde geld voor eclipse en zend studio
Voor webdevelopment gebruik ik graag Eclipse.
handige auto complete functies en het is goed uit te breiden.
wel eerst het een en ander instellen.

Er is volgensmij ook phpcreator of iets dergelijks, moest het op stage gebruiken maar vind het persoonlijk een stuk minder fijn dan eclipse.
Dat is vreemd... Ik kan niet meer zonder!

in veel talen kan ik gewoon "pubf" + tab doen. De cursor verspringt naar de functie/methode naam zodat ik die kan typen. Nog een tab en ik kan de argumenten typen en nog een tab en ik zit in de body. Werkt heerlijk gewoon.

Of andere dingen zoals een variabele definiŽren en met een paar toetsaanslagen ineens de getter en setter te genereren.

Eenmaal je het wat gewoon bent en je het ingesteld hebt naar je eigen voorkeuren helpt het je echt om veel sneller te werken dan ervoren. Rommel die je vroeger constant opnieuw moest typen gaat nu gewoon vanzelf.
"It looks like you are writing a letter" :P

Volgens mij bedoelt Darpa niet zozeer een echte autocomplete te willen maken zoals 'je typt een woordje en de IDE typt het automatisch af met haakjes en al'. Maar eerder een slim systeem dat hele blocks code schrijft.
En dat is tevens een toekomst die ik wel zie gebeuren, een computer die steeds meer low level voor zijn rekening neemt en de programmeur die steeds minder typt en steeds meer continue aan het denken is over complexe stukken software in plaats van tijd verdoen aan het voor de hand liggende.
Ik denk niet dat ze het hier over dat soort code completion hebben. Daar hoef je namelijk geen onderzoek naar te doen, dat heeft jetbrains al gedaan.

Ik vind het persoonlijk heerlijk dat Resharper er voor zorgt dat mijn code aan de afgesproken conventies voldoet, dat maakt teamwork een stuk eenvoudiger. Negen van de tien keer wil ik die haakjes e.d en dus bespaart het een hoop werk.

Maar ik heb wel al mijn code zelf geschreven en ik weet precies wat ieder stukje doet. Resharper suggereert ook vaak om lambda expressies te maken die volkomen onleesbaar zijn. Tuurlijk de code gaat van 5 naar 1 regel, maar als ik het niet meer kan lezen, dan doe ik het niet.

Dat betekent dat als ik een AI mijn code laat schrijven (wat hier bedoelt wordt) ik die code vervolgens eerst moet doorgronden voordat ik het kan accepteren. Ik weet niet hoe het voor jullie is, maar andermans code doorgronden en aanpassen is vaak een hel en kost zeeen van tijd. Dan schrijf ik het liever helemaal zelf.

[Reactie gewijzigd door Omega Supreme op 10 november 2014 00:34]

Het hangt echt af van welke editor je gebruikt. In Visual Studio vind ik het heel handig, maar in MonoDevelop zal ik het altijd uitzetten. Niet dat je uberhaupt MonoDevelop wil gebruiken...
haha ik voel je pijn.. maar ik gok dat het een kwestie van smaak is. wij houden er niet van, anderen weer wel (vermoedelijk ben jij ook, net als ik, iemand die in word processors alle hulpdingetjes uitzet)
Het lijkt me te hoog gegrepen. Wat de software moet weten is wat het programma moet doen, en dat kun je alleen maar aangeven door het zelf te programmeren.
Praktisch voorbeeld waar dit wel van toepassing kan zijn is bij toepassen van bekende libraries:

/*Pseudocode, niet de echte juiste benamingen /
HRESULT EnigneClass::InitializeEngine(bool Windowed = false, int Width = 800, Height = 600)
{
this->UnrealEngine->Init.... (geeft plots suggesties hoe heel deze functie kan afgewerkt worden met afhandelen van alles, maken van een kader voor op te renderen (indien windowed), etc etc
}


Ook bij Unity3D, of algeme webdevelopment voor browser sessies, en andere zaken die echt wel altijd terugkomen, maar waarvoor een framework niet flexibel genoeg is.
Dit is toch al wat standaard autocomplete/intellisense doet.
Zeker als de bouwer van de library de API goed op orde heeft, met heldere intuÔtieve naamgeving kom je er een aardig eind mee zonder de docs te hoeven lezen.
Echt nieuwe software uiteraard niet, maar elke programmeur weet dat hij vaak delen schrijft die anderen al eindeloos vaak geschreven hebben, enkel om de basis van het programma te voorzien. Niet elk onderdeel van innovatieve software is innovatief. En als we tijd kunnen besparen bij dat repetitief werk, is dit zeker welkom.
Ik hoop dat het niet hetzelfde niveau is als menig autocomplete smartphone sms software, want dan wordt het een puinhoop. Ik hoop eerder dat het een tool wordt die een hoop werk bespaard.
Als dit eenmaal kan, hoever zouden we dan nog afstaan van een systeem waarbij je aan de computer gewoon omschrijfd wat je wenst en de computer stelt dan zelf een programma samen?
Gedetailleerd omschrijven wat je wenst, dat is wat programmeren in essentie is. Met klassieke programeertalen als C en C++ zeg je nog hoe je computer dat moet doen, maar bijvoorbeeld met declaratieve talen of beschrijvende talen laat je dat achterwege/over aan de compiler. Het probleem is dat je altijd meer wilt dan dat je zelf denkt te willen. Deze software zal niet snel het probleem van vage requirements oplossen.
Wat het wel op kan lossen is dat je iets aan het maken bent dat iemand anders al eens heeft gemaakt. Dan wil je waarschijnlijk dezelfde requirements vervullen als ide andere(n) en kan automatische software je wel helpen.
edit:
Klassieke talen aangepast

[Reactie gewijzigd door 84hannes op 9 november 2014 12:52]

Nah, C en C++ zijn gewoon scripttaaltjes zoals html, echt programmeren doe je in low-level talen zoals Assembly of gewoon direct in machinetaal! ;-)

Klassieke talen zijn trouwens Latijn, Sanskriet, Pali, etc.

Het grootste probleem van programmeren blijft dat je niet correct je acties defineerd, daar gaat een computer programma voorlopig niet aan helpen om van iemand die dat niet kan het opeens wel kan...
Nah, C en C++ zijn gewoon scripttaaltjes zoals html, echt programmeren doe je in low-level talen zoals Assembly of gewoon direct in machinetaal! ;-)
Ik snap dat het sarcastisch bedoeld is, maar html een scripttaal noemen gaat te ver, het zou niet eens samen met programmeren in een alinea mogen...
Anders kan je net zo goed MarkDown een scripttaal noemen.
Dan is dit dus ook programmeren ;)
Dus iedereen kan programmeren!!! 8-)
De CAM wereld kent dit in principe al. Hier laadt je een Solid in welke je bewerkt wilt hebben. Het CAM-Softwarepakket laadt hier een "roughing" algoritme op los en zal bewerkings banen aanmaken.
Als je dit door de postprocessor (als je goed in de video kijkt zie je dat dit woordt op een whitboard wordt geschreven) gooit zul je allemaal xyz coŲrdinaten krijgen.
Zal je dit zelfde product met de hand programmeren dan zul je bijv. 1 XY-contour programeren en deze op verschillende z niveau's oproepen.

Een misschien nog wel mooier voordbeeld is 3d printen, je laadt een stl in, postprocessen en code voor het printen van je product.

Bij beide processen zit er echter een bak aan algoritmen op het proces zo efficient aan te sturen.
Je hebt al wel model gebaseerd programmeren. Dan maak je een model met de gewenste functionaliteit en dan maakt de computer er code van. De code is dan niet meer makkelijk te debuggen. Het staat nog een beetje in de kinderschoenen, deze techniek.
Wat mij vooral interessant lijkt is een software zoals deze die mijn programmatie code geheel zou begrijpen, en opnieuw zou schrijven of bijwerken maar dan op een manier dat ondanks exact zelfde resultaten van de functies (of gehele classen) vele male beter geoptimaliseerd is en alle bekende beveiligingsproblemen er op loslaat. Niet alle beveiligingsproblemen kunnen altijd opgelost worden zonder dat het eind resultaat of de input veranderd of anders wordt verwerkt, dus een dergelijke software die intelligent omgaat met de code en informatie geeft van mogelijke problemen, zou enorm handig zijn.

Praktisch voorbeeld:

void SwitchInt(int &A, int &B)
{
int temp = A;
A = B;
B = temp;
}

Zou deze van kunnen maken, plots via macro, zonder bijkomende functie en zonder bijkomende temp variable:

#define SwitchInt( a, b ) a += b;\
b = a - b; \
a -= b;

Het zou dus heel aangenaam zijn als programmeur dat wanneer je die functie schrijft plots de IDE mij vertelt dat er een betere bekende manier bestaat. Of dat ik plots een mogelijke memory overwrite of memory leak heb in mijn functie.

[Reactie gewijzigd door xp65 op 9 november 2014 11:34]

Het voorbeeld die je geeft is enorm moeilijk te optimaliseren. Want in de tweede versie ga je de variabelen bij elkaar optellen, wat niet altijd mag. Stel dat in A en B al INT_MAX zit, dan gaat de optelling overflowen.

Daarnaast is het inlinen van functies niet altijd een voordeel. Toegegeven dat een function call tijd kost, maar als de functie op vele verschillende plaatsen regelmatig opgeroepen wordt, kan een cache miss slechter uitvallen dan een function call. Daarnaast vergroot het meestal de file size, iets wat op bvb een microcontroller met beperkte opslag juist een te vermijden issue is. In mijn opinie is het best om de compiler zelf te laten beslissen of hij een functie al dan niet inline't - zie ook dit antwoord op stackoverflow voor meer informatie over inlining.

Daarnaast lijkt deze tool mij niet echt een vorm van optimalisatie (dat is de taak van de compiler), maar eerder van "intellisense": op basis van wat je in de vorige x regels getypt hebt, een suggestie doen voor de volgende. Een beetje zoals design patterns werken. Iemand heeft mogelijk (in alle code van github/Sourceforge/...) al een soortgelijkig probleem gehad, en dus probeert dit systeem jouw code aan te vullen met de beschikbare code - mits enige aanpassingen zoals variablenamen.
Correct. Mijn voorbeeld was ook maar uit de duim gezogen, en er zijn inderdaad ook nadelen aan zoals INT_MAX.

Maar er zijn vast realistischer grotere voorbeelden, bijvoorbeeld iemand die voor de functie "abs" plots zelf in code vele regels gaat schrijven omdat men deze functie niet kent, of kort samengevat waarbij de software detecteert dat vele regels eigenlijk hetzelfde kan doen als 1 kleine regel algemeen.
Correct. Mijn voorbeeld was ook maar uit de duim gezogen, en er zijn inderdaad ook nadelen aan zoals INT_MAX.
In veel gevallen zal je bij deze macro inderdaad overflow hebben. Dat is echter geen nadeel - Overflow is alleen een nadeel als het de bedoeling is om getallen op te tellen of af te trekken. Dat is hier niet zo. Hier worden alleen bitpatronen gemanipuleerd. En in dit geval is overflow juist gťťn probleem. Reken maar na.

Wat dus wel een probleem is, is dat bij de macro a en b meermaals geŽvalueerd worden. SwitchInt(*(px++),*(--py)); levert dan interessante resultaten (px, py zijn pointers naar int).
Overigens kun je ook de volgende code schrijven. En die werkt ook voor floats, etc - maar het nadeel blijft de herhaalde evaluatie:
#define swap(a,b) ((a)^=(b), (b)^=(a), (a)^=(b), 0)
Worden programmeurs daar niet alleen nog maar luier door? Een beetje richting het niveau van mensen die alleen nog maar kunnen rekenen met een pocket calculator of een vergelijking oplossen dmv. de computer. Het lijkt me uitermate handig al leer middel, mits goed uitgevoerd, maar de praktijk leert dat in het bedrijf mensen minder willen leren en meer zo min mogelijk werk willen doen met de meeste resultaten. Voor een gebruiker is het soms al een probleem dat ze op knopje x drukken en dan y gebeurt zonder dat ze doorhebben wat ze eigenlijk doen. Wat gebeurt er als programmeurs ophouden met denken en de mentaliteit gaan hebben "Dat lost m'n IDE/compiler wel op."...
Worden programmeurs daar niet alleen nog maar luier door? Een beetje richting het niveau van mensen die alleen nog maar kunnen rekenen met een pocket calculator of een vergelijking oplossen dmv. de computer. Het lijkt me uitermate handig al leer middel, mits goed uitgevoerd, maar de praktijk leert dat in het bedrijf mensen minder willen leren en meer zo min mogelijk werk willen doen met de meeste resultaten. Voor een gebruiker is het soms al een probleem dat ze op knopje x drukken en dan y gebeurt zonder dat ze doorhebben wat ze eigenlijk doen. Wat gebeurt er als programmeurs ophouden met denken en de mentaliteit gaan hebben "Dat lost m'n IDE/compiler wel op."...
Goede programmeurs hebben een hekel aan hetzelfde werk steeds opnieuw doen. Die gebruiken dus abstracties die ze zelf schrijven, of die anderen geschreven hebben (functies, klassen, modules, ...). Dat is een vorm van luiheid. Dat zijn ook de mensen die voor hetzelfde werk uiteindelijk meer resultaat boeken.

Slechte programmeurs zul je altijd hebben. Dat is het type waar jij het over hebt. Dat zijn de types die liever een stuk code steeds kopiŽren, en dan met een paar wijzigingen gebruiken, in plaats van een functie / procedure / class / etc. te schrijven.

Slechte managers zul je ook altijd hebben, die niet willen betalen voor goede programmeurs, en/of voor goede code. Omdat ze nu een produkt willen, en tegen minimale kosten. En omdat onderhoudskosten niet hun probleem zijn, maar van een andere afdeling of zo.

Mensen willen volgens mij meestal best leren, maar niet als daar geen ruimte voor is, in de planning, in de bedrijfscultuur, etc.
Slechte programmeurs zul je altijd hebben. Dat is het type waar jij het over hebt. Dat zijn de types die liever een stuk code steeds kopiŽren, en dan met een paar wijzigingen gebruiken, in plaats van een functie / procedure / class / etc. te schrijven.
Hoho. Dat is niet slecht dat is juist goed! De inefficientie van meerdere malen dezelfde code kan een moderne compiler gemakkelijk oplossen. De leesbaarheid van de code gaat op deze manier juist met sprongen voorruit, geen complexe en cryptische functies waarvan niet in een keer duidelijk wat het doet en waarom het dat doet. De onderhoudbaarheid van 5x een nagenoeg identiek stuk code aanpassen acht ik ook veel groter dan een complexe functie doorgronden en deze correct aanpassen. Het grote probleem met moderne software is het excess aan complexiteit, vaak gemaakt omdat het kan. Wie gaat werken met gegenereerde code, tabellen, functiepointers moet zich nog eens goed achter het oor krabben of dit niet kwalijk is voor het onderhoud en of dat "keep it simple" niet een betere filosofie is.
Dat ligt geheel aan de kwaliteit van m'n IDE/compiler.
Ik onthoud ook geen telefoonnummers meer, sinds mijn mobieltje dat veel beter doet.
Een nummer onthouden is niet oplossend denken, twee heel verschillende dingen, das een gemak vs. een probleem niet te hoeven oplossen.
Voor veel werk is de oplossing al eens bedacht, of ligt er wat op de plank dat er veel op lijkt. (- patterns). Voor mij is dat wel vergelijkbaar met het onthouden van een nummer, maar dat geldt wellicht niet voor iemand die geen ervaring heeft. Maar dan zou iemand misschien wel kunnen leren van die autocomplete.
Ik hoop dat je je realiseert dat deze macro NIET hetzelfde doet als de functie.
Met name leuke effecten heeft heeft als jer iets anders dan int's in stopt....

B.v: De functie pikt geen float maar de macro wel EN ZONDER DAT DE COMPILER daarvoor een error geeft..

Ik snap waar je naar toe wilt, maar je voorbeeld is wat ongelukkig...
Correct, maar diezelfde artificiŽle intelligentie zou jou direct op de vingers tikken als je dat probeert toe te passen met andere type variabelen :)
Laten we dat maar hopen ;)
Die laatste heeft anders een stuk meer overflow issues dan de eerste :x maar dit kan erg nuttig zijn voor low level talen, dus ik ben benieuwd
software zoals deze die mijn programmatie code geheel zou begrijpen, en opnieuw zou schrijven of bijwerken maar dan op een manier dat ondanks exact zelfde resultaten van de functies (of gehele classen) vele male beter geoptimaliseerd
Dit is dus wat een taal zoals Java o.a. al voor een gedeelte doet. Ok, je moet ook weer niet volledige onzincode gaan schrijven, maar er zitten zoveel optimalisaties in de Java-compiler waar je als "normale" Java-programmeur eigenlijk niet tegenop kan optimaliseren/efficientere code kan schrijven.

En verder zijn er natuurlijk nog de gereedschappen zoals Sonar (of binnen je IDE) met Findbugs, PMD en Checkstyle die ook al een hoop code analyseren op afwijkingen en je daar rapporten over geven.

Tel daar nog bij op ontwikkelomgevingen zoals o.a. IntelliJ die je echt een heleboel slimme tips geven terwijl je aan het programmeren bent. Je kunt het lui noemen, maar ik vind het handig als een IDE automatisch de juiste variabelen al weergeeft i.p.v. dat je door een lijst zelf moet gaan zoeken welke variabele het ook alweer om ging. Of templates die slimme standaardcode voor je neerzetten. Er zullen vast een hoop programmeurs zijn die graag liever 100% alles zelf willen doen, als ze daarmee net zo productief zijn en net zulke kwaliteit software opleveren, lijkt me dat geen probleem. Maar ik zie met het gereedschap dat ik gebruik en de code die ik er mee analyseer dat programmeurs waarvan beweert wordt dat ze "goed" zijn de definitief van "goed" nogal breed is.

Oftewel, ik ben benieuwd wanneer we de resultaten van dit DARPA-onderzoek terugzien in de praktijk en wat voor programmeurs het voor de toekomst oplevert ;)
(in de Java Runtime, de compiler doet juist erg weinig aan optimalisatie)
Ik schreef compiler maar bedoelde inderdaad runtime :Y)
Dit kan nog wel eens erg lastig worden. Aangezien een puristische programmeur zo veel mogelijk DRY schrijft zal hij zelf al proberen om herhalende patronen te minimaliseren. Wat er overblijft zijn juist de onvoorspelbare delen van de code.
Aan de andere kant biedt een dergelijke tool wel uitermate veel inzage in de manier waarop code geschreven wordt. Ik hoop dat de algoritmes open-source worden.
Eens. Als een tool kan voorspellen wat je schrijft, is er iets mis met de code. De tool is symptoonbestrijding.

Doet me denken aan Rails Generators... Rails zou DRY moeten zijn, maar gezien je voor vele gems simpelweg generators hebt, wat dus zorgt voor niet-DRY code, is er toch fundamenteel iets niet in orde.
Eens. Als een tool kan voorspellen wat je schrijft, is er iets mis met de code.
Oh, is dat zo?

Als ik het volgende schrijf: flip :: (a -> b -> c) -> b -> a -> c

Dan kan een tool aan de hand van deze type-signature automatisch de implementatie afleiden. Wil je nu beweren dat er wat mis is met deze code?

Of als we een iets ingewikkelder type-signature nemen: bind_cont :: ((a -> r) -> r) -> (a -> (b -> r) -> r) -> (b -> r) -> r

Ook hiervoor kan automatisch de implementatie worden afgeleid. Wil je beweren dat er iets mis is met de Continuation monad?
Abc bac is geen flip en niet voorspelbaar. Bovendien, waarom voorspellen wat een flip kan zijn als je een library met flip implementaties kan bieden
Abc bac is geen flip en niet voorspelbaar.
Het is een functie die de argumenten van een gecurryde functie omwisselt. Het is analoog aan de propositie (a -> (b -> c)) -> (b -> (a -> c)) die ook af te leiden is. Deze propositie vertelt je dat je de antecedenten in een implicatie kan omdraaien.

En wat is er niet voorspelbaar aan? Je kunt een programma schrijven die de implementatie afleidt.
Bovendien, waarom voorspellen wat een flip kan zijn als je een library met flip implementaties kan bieden
Zo'n library moet ooit eens geschreven worden door iemand, nietwaar? Tools kunnen library-writers dus helpen met het implementeren van functies.

Voor de applicatieschrijvers kun je tools aanbieden die je kunnen informeren dat bepaalde functionaliteit al in een library bestaat, zodat deze niet zelf de functionaliteit hoeft te implementeren. Voor Haskell bestaat er bijv. een zoekmachine die op type-signature kan zoeken. Als je bijv. (a -> b -> c) -> b -> a -> c als query geeft, dan verschijnt als eerste resultaat de flip functie.
Zeker, maar sommige functies zijn al vaker in dezelfde taal geschreven. Hoe ik het begreep is dat er een mogelijkheid komt om bijvoorbeeld een zo'n functie te pullen, waardoor de opzet snel staat en je deze naar wens kan aanpassen.
In de natuur komen zelf herstellende en zelf corrigerende mechanismen veel voor. Deze ontwikkeling is eigenlijk een natuurlijke volgende stap in de ontwikkeling van het programmeren.

Heel vroeger werden met schakelaars de nullen uit en de enen aan gezet, een andere schakelaar zette de instructie aan. Later werden aan de computer octale instructies gevoerd, later weer werd de hogere programmeer taal assembler gebruikt. Omdat die bij complexere programma's niet voldoende overzicht bood kwamen weer hoger programmeer talen als COBOL, C, Pascal; op hun beurt gevolgd door IDE omgevingen die het programmeren weer ondersteunt.

Dat laatste zit het hem nu in, dat vergeten jullie in de reacties. Dit is een ondersteuning voor het programmeren. Je kunt het gebruiken, of niet. Als je het gebruikt kun je het resultaat evalueren. Wellicht scheelt het gebruik van deze tool je uren programmeerwerk, omdat het testen van de door de tool gegenereerde code veel minder tijd kost dan je anders zelf kwijt was geweest aan het programmeren.

Ook kan ik mij voorstellen dat gebruik van de tool of een dergelijke tool door bedrijven in de toekomst voorgeschreven wordt voor het testen van de juistheid en veiligheid van af te leveren software omgevingen, dan wel voor het testen van de integriteit van software omgevingen waar modules aan toegevoegd of in gewijzigd worden.

Het is gewoon een stukje vooruitgang. Mooi om te zien. Meer lezen over zelf corrigerende mechanismen? Zie Google wetenschapsartikelen (link).
Bovendien zijn veel compilers van zichzelf al "slim" op een vergelijkbare manier, deze zullen een aantal regels doorlopen om fouten op te sporen en zullen vaak ook optimalisaties uitvoeren (zie garbage collection). Als dit er voor zorgt dat dergelijke optimalisaties en fouten zichtbaar zijn voor de programmeur voordat er Łberhaupt gecompileerd wordt kan ik me voorstellen dat dit veel tijd bespaart (en oorzaken van bugs vermindert). Bovendien kan dit er voor zorgen dat er dus nog slimmere maar mogelijke ongewenste optimalisatie en fout-opsporing kan worden toegepast (zoals wordt beschreven in het artikel), omdat de programmeur dan duidelijk kan zien wat er wordt aangepast en het dus ook kan afwijzen indien dit ongewenst is.

Het lijkt mij in ieder geval wel wat.
Zulke tools kunnen ook flink in de weg gaan zitten daarbij zijn de meeste projecten dusdanig specifiek op een bepaald doel gericht dat er in feite alleen maar maatwerk bij komt kijken.
De meeste IDE's schotelen al de relevante informatie voor en dat is meer dan voldoende.

De in het artikel benoemde methodiek lijkt me alleen handig als je er specifiek om vraagt maar niet voor auto-completion.
Programmeren is tegenwoordig al veel copy&paste van bestaande voorbeelden. Je zit met een probleem, je zoekt op google.com, je komt uit op stackoverflow.com, en je past dat voorbeeld aan naar jouw wensen. Het nadeel is dat je zelf nog nauwelijks iets leert.
Nooit copy pasten maar altijd overtikken. Ben je veel meer bewust van wŠt je nu eigenlijk tikt. Maar het komt zelden voor dat ik mijn code daar kan vinden, meestal werkt zelf tikken sneller en beter.
Op zich is er niks mis met copy/pasten uit StackOverflow, maar je moet weten wat je aan het copy/pasten bent. Regelmatig copy ik een voorbeeld naar mijn editor om het dan aan te passen tot wat ik nodig heb. Zeker voor iets langere blokken code is dat toch wel handig. Natuurlijk moet je er wel voor zorgen dat het in dezelfde stijl als de rest van het project geschreven is en dat je echt goed begrijpt waarom alles gedaan wordt.

Natuurlijk, het is zeldzaam dat je iets vindt wat de moeite is om te copy/pasten. Meestal is het probleem op StackOverflow anders maar kan het opgelost worden met een gelijkaardige aanpak. Dan is het natuurlijk kwestie van te kijken hoe ze het daar opgelost hebben en dat dan toe te passen op je eigen project.

Ik heb trouwens willen merken dat een aantal mindere programmeurs niet vaak dingen van StackOverflow halen. Ik ken er een aantal die StackOverflow links quasi volledig negeren als de vraag niet exact hetzelfde probleem is. Ik moet ze regelmatig aanporren om toch even naar de antwoorden te kijken... Daar staat vaker dan je denkt iets dat toch helpt. Diegene die dus op StackOverflow hun antwoorden vinden en die aan de praat krijgen in hun code zijn al een stap voor op de programmeurs die niet eens tot daar geraken.
Regelmatig copy ik een voorbeeld naar mijn editor om het dan aan te passen tot wat ik nodig heb.
[..]
Ik heb trouwens willen merken dat een aantal mindere programmeurs niet vaak dingen van StackOverflow halen
Ik haal zťlden wat van SO, of van welke andere site dan ook. Misschien komt dat omdat ik uit een tijd kom waarin ik moest leren programmeren zonder de aanwezigheid van internet, maar ik kan me nauwelijks voorstellen dat elke andere ervaren programmeur nog regelmatig dingen van internet copypaste/overtypt. Uiteindelijk zit je met een probleem, en je gebruikt het internet (of andere resources) om dat probleem te doorgronden en zo op te kunnen lossen, niet om de code van die oplossing te vinden. Maar over het algemeen kom je er wel uit door simpelweg de documentatie van de API te lezen.
Spijtig genoeg is de documentatie niet altijd in orde, zeker als je wat kleinere libraries gebruikt. Ook heb je soms gewoon last van vreemde quirks die niet gedocumenteerd zijn. De kans is dan groot dat iemand anders ook al hetzelfde wou proberen en het daar gevraagd heeft. Je kan dan op je eentje een uur zitten vloeken en proberen, of je kan even rondkijken hoe andere mensen het doen. Je idee van een "ervaren programmeur" die alles zelf doet en probeert te doorgronden bestaat niet. Iedereen gebruikt libraries dus iedereen gebruikt code van anderen. Wat is "filosofische" het verschil tussen een functie gebruiken uit een library of een functie die je op SO gevonden hebt? Niemand kan alles begrijpen. Als ik een tangens nodig heb dan gebruik ik een library daarvoor. Ik moet helemaal niet weten hoe je nu precies de numerieke benadering daarvan op een efficiŽnte manier programmeert. Mij lijkt het gewoon een dubbele standaard.

Natuurlijk ligt de kwaliteit op SO gemiddeld gezien een pak lager dan je in een library gaat vinden, maar daardoor moet niet meteen alles de deur uit. Als je de code bekijkt zie je heel snel of het is wat je zoekt en of het een beetje proper geschreven is. Dan kan je nog altijd de keuze maken om het anders te doen, of de inspiratie gebruiken. Je hoeft niet letterlijk te copy/pasten om een oplossing van SO te gebruiken. Een expert die al 10+ jaar met hetzelfde werkt heeft er niet veel aan, maar als je een nieuwe taal of framework begint te gebruiken is SO toch enorm handig. Het is gewoon een extra bron van informatie die je net zoals de rest van het internet met een korreltje zout moet nemen.

En natuurlijk kijk ik eerst in de documentatie. Eerst kijk ik daar, dan probeer ik het even zelf maar als dat toch iets moeilijker blijkt zoek ik het even op. Er zijn nog genoeg problemen waarvoor je geen oplossing kan vinden dus er zijn nog genoeg mogelijkheden om je er in te verdiepen.
Copy/Pasten uit StackOverflow? nou liever niet als je ziet wat voor rommel je daar allemaal tegenkomt, hooguit als laatste resource punt.

Altijd zelf je code opstellen en in eerste instantie de gerelateerde helpfile/knowledge base raadplegen van de ontwikkeltaal/omgeving.

[Reactie gewijzigd door BoringDay op 9 november 2014 17:18]

Misschien ook de reden van zoveel bugs?
Als mensen al niet eens meer het geduld hebben om iets na te lezen voor het posten, hoe moet het dan gaan als de computer beter denkt te weten dan jij wat je wilt programmeren?

Nee, hier heb ik - als ICT'er - absoluut geen vertrouwen in. Autocomplete zet ik dan ook altijd uit. Ook al is Swiftkey eng nauwkeurig met voorspellen, hij weet ook niet alles wat ik wil schrijven. En voor mij geldt dat als ik op zoiets niet 100% kan vertrouwen, het nutteloos is.

Dit werkt misschien voor 13 in een dozijn shell scripts die je ook kunt overnemen van iemand anders, maar ik zou hier geen targetting systeem voor een kruisraket mee willen maken... :+
Dat is dan ook geen programmeren maar spaghetti maken. Als jij op die manier code produceert ben ik blij dat ik niet met jouw code hoef te werken, het wordt er echt een enorm ondoorzichtige chaos van.

Programmeren doe je zelf, met je hoofd. Voorbeelden op Stackoverflow e.d. kunnen zeker nuttig zijn maar copy/paste is een enorm slecht idee. Leer eruit wat je eruit moet leren en pas het zelf toe.
De basisregel zou moeten zijn dat je begrijpt wat je copypastet. Voor Darpa's autocomplete zou precies hetzelfde moeten gelden: alleen gebruiken als je het volgt, en anders zet je jezelf eerst in learning modus. Je collega's zullen je dankbaar zijn.
Zal toch programmeurs specifiek zijn. Als je kijkt hoe je met de huidige tools een persoonlijke workflow kunt creeŽren. Zo maak ik zelf veel gebruik van Sublime Text 3 (kale editor, enorm tot in de details uit te breiden. Dus alleen wat je nodig hebt en gebruik van maakt) icm Emmet. Scheelt al enorm veel tikwerk.

Zo te lezen gaat dit zelfs een stap verder en moet hij dadelijk hele concepten kunnen neerzetten. Ben benieuwd hoe dit in de praktijkz al gaan werken.
Zie ook DWIM: http://www.catb.org/jargon/html/D/DWIM.html en lees vooral de anecdote aan het einde
Ik vraag me af hoe met copyright om zal worden gegaan. Bovendien, wat wordt straks gezien als plagiaat?
Dit zeflde vroeg ik me dus ook af , uit ervaring weet ik dat er best discussies zijn binnen opensource project voor dat er iets van code gebruikt wordt uit andere project of zelfs libs . Er zijn namelijk heel veel varianten copyrights alleen al binnen sourceforge.
Daarnaast als ergens geen copyright op zit, maar er is wel een bekend wie de ontwikkelaar is dan is de copyright aan degene persoonlijk.

[Reactie gewijzigd door citegrene op 10 november 2014 01:05]

Op dit item kan niet meer gereageerd worden.



Apple iOS 10 Google Pixel Apple iPhone 7 Sony PlayStation VR AMD Radeon RX 480 4GB Battlefield 1 Google Android Nougat Watch Dogs 2

© 1998 - 2016 de Persgroep Online Services B.V. Tweakers vormt samen met o.a. Autotrack en Carsom.nl de Persgroep Online Services B.V. Hosting door True