C++ och dess framtid att programmera minnessäkert - Hur går utvecklingen?

Permalänk
Datavetare
Skrivet av klk:

För användaren spelar det knappt någon roll alls, fungerar applikationen som förväntat så är användare nöjd.

Men diskussionen här tar upp dumheterna USAs myndigheter gått ut med att skriva kod i "minnessäkra" språk. Det är nästan lika dumt som att säga att bilar inte får lov att köra med hjul så därför tror jag inte på orsakerna de nämner. Tror det är något annat som ligger bakom.

Skulle jämföra det mer med att vi tids nog inte kommer få köra ICE-bilar. Men precis som det lär det vara en bra bit bort till ett direkt förbud.

För i nuläget handlar det inte om något förbud. Däremot behöver man framåt ha en rimligen förklaring till "varför" om man tänker utveckla i C eller C++.

Sett en del kommenterar kring det om att affärsmässigt kan det medföra att man lättare kan bli stämd om man väljer C eller C++ och det sedan skiter sig i form av säkerhetshål. Men det är ju spekulation i nuläget.

Och är ju som sagt så att även ISO C++ gänget håller med att något bör göras. De är bara oense om exakt vad som behöver göras framåt och är väl egentligen vägen de i slutändan kommer följa som är frågeställningen i denna tråd.

Tycker Bjarne S har en rätt naiv inställning till just detta problem. Hans inställning verkar mest vara: men vi har ju skrivit fina guidelines och om folk bara följde dessa till 100 % skulle det inte finnas några problem. Vilket inte stämmer om man inte räknar med att folk skriver felfri kod.

Det Rust visat är att det till och med är möjligt att fånga race-condition, use-after-free och en lång rad problem vi historiskt haft gott om i C och C++, och att dessa kan hittas redan av kompilator!

Safe C++ förslaget vill ju ta ISO C++ ungefär dit Rust är idag. Problemen är nog primärt två där. Dels blir resultatet något som är rätt annorlunda från dagens C++, det ser väldigt mycket ut som Rust skrivet med C++ syntax. Dels hjälper det inte existerande kod och huvudanledningen att använda C++ (eller C) idag är för att man bygger vidare på existerande kodbas(er) i dessa språk.

Skrivet av klk:

Applikationsutvecklare har hårt tryck på sig att utveckla saker som fungerar för kunden, gör det inte det så blir det jobbigt.

Saker har ju ändrats med åren. En sak vi har idag är att multi-core är normen och det finns flera tekniska fördelar med att använda GC-språk när man jobbar med mulitrådade program. Dock finns ju också systemprogrammerings-fall där GC inte är lämpligt, så man kan inte släppa manuell minneshantering helt (men det är en allt smalare nisch).

Skrivet av klk:

Och skulle USA och Europa gå så långt som att förbjuda C++ kommer asien att slakta oss inom mjukvara också. Våra politiker verkar göra allt de kan för att förstöra förutsättningarna och flytta all tillverkning ill asien.

Ingen pratar ju om förbud. Samma gäller ju tech-jättarna som alla har en av världens största C++-kodbaser.

Det handlar om att man inte längre ska välja C eller C++ av slentrian. Om ett minnessäkert språk fungerar ska man välja det, om man måste välja C eller C++ får man förklara varför och sen köra på.

Senaste embedded-projektet jag jobbade med använde med fördel Go (var lite av en lyckträff, initialt stod valet mellan C++ och Rust men visade sig att just i detta fall fungerade Go faktiskt bättre).

Skrivet av klk:

För mig så är det framförallt problematiskt med att editorn är seg på att hänga med med markeringar. Typ som att om man rättar en sak som markerats som fel så dröjer det en stund innan editorn fattar att det är rättat. Det är speciell så när jag kör WSL.
Debuggern går heller inte att jämföra med Visual Studios, tänker då på C++
VSCode har obland svårt att hoppa till deklarationer/definitioner. Kör man CMake fattar den inte alls (i alla fall inte för mig), variabler och annat i CMake alltså

Ah, nu har jag faktiskt aldrig använt VS Code för C++ mer än väldigt simpla saker. Är något år sedan jag senaste jobbade med C++ och senast användes Rider (och om inget radikalt har hänt senaste 2-3 åren skulle jag välja Rider igen utan att blinka). Innan det använde jag primärt Emacs för C++.

Hur bra/dålig intellisense fungerar i VS Code beror ju helt på "language services" för det språk man använder. Tar man Go (där dessa saker är helt skrivna i Go BTW) så är det blixtsnabbt och otroligt stabilt. Bl.a. då VS Code rätt mycket är förhandsvalet från Go-gänget.

Rust fungerar också väldigt bra i VS Code, likaså Typescript och Python.

Edit: använder i.o.f.s. Platform I/O en hel del ihop med VS Code. Även om det rent tekniskt är C++ handlar det ju om extremt simpel C++ som mer är C med lite klasser... Platform I/O är ju ett ramverk för att jobba med mikrokontrollers.

Visa signatur

Care About Your Craft: Why spend your life developing software unless you care about doing it well? - The Pragmatic Programmer

Permalänk
Medlem
Skrivet av Yoshman:

Safe C++ förslaget vill ju ta ISO C++ ungefär dit Rust är idag. Problemen är nog primärt två där. Dels blir resultatet något som är rätt annorlunda från dagens C++, det ser väldigt mycket ut som Rust skrivet med C++ syntax. Dels hjälper det inte existerande kod och huvudanledningen att använda C++ (eller C) idag är för att man bygger vidare på existerande kodbas(er) i dessa språk.

Kort svar, skall läsa sedan men angående rust så kanske OT men jag tror inte jag mött utvecklare som är så förtjusta i ett språk som just de som sitter i Rust. Jag har svårt att förstå det för personligen har jag stora problem med att gilla den syntaxen och jag tillhör de kraftigt ogillar förkortningar. Rust har ju valt att förkorta på en hel del ställen.

Pratar man med rust utvecklare och frågar varför de förkortar, varför de inte orkar skriva hela namnet så bli man avsnäst ibland.
En annan sak jag ogillar är att språket inbjuder till "message chains". Kod med mycket message chains är inte rolig att refaktorera och enligt mig en av de värre code smells. Koden kan se trevlig ut, speciellt om de har någon formaterarare och kanske endast har 80 teckens bredd men det är inte bra kod. Är jag med i projekt är kodformaterare det som ryker först om jag får vara med och påverka.

Men angående minne, rust har väl mer eller mindre valt att lägga minne i något som liknar std::unique_ptr ?

Permalänk
Medlem
Skrivet av klk:

Är jag med i projekt är kodformaterare det som ryker först om jag får vara med och påverka.

Jag vet inte om jag förstod dig rätt här, men är det alltså så att du föredrar att projektet inte använder t.ex. clang-format?
Varför tycker du att det minskar läsbarheten?

Permalänk
Medlem
Skrivet av Perkoff:

Jag vet inte om jag förstod dig rätt här, men är det alltså så att du föredrar att projektet inte använder t.ex. clang-format?
Varför tycker du att det minskar läsbarheten?

Korrekt, clang-format är en av de värre saker att ta med i projekt. Men då pratar jag också skalbarhet och att det är utvecklare med lite erfarenhet. Är det nya utvecklare med så kan de sätta på clang-format lokalt för dem själva men med flexibla inställningar.

En programmerare måste lära sig vårda sin kod och det gör man inte med verktyg som clang-format, det tar också bort kreativitet i hur man kan skriva kod för att göra den mer eller mindre hanterbar.

När du skriver till mig: "Varför tycker du att det minskar läsbarheten?"
Redan där har du kört av vägen om man kan uttrycka sig så. Ingen läser kod i större projekt, att skriva kod för att läsas är vansinne. Tyvärr görs det och där det sker går det långsamt.
När man skriver kod är det viktigt att skriva för skalbarhet, att koden är sökbar och att mönster upprepar sig.

Exempel:
I C++ finns en hel del "container" klasser, klasser som vector, list, set, map mm
Har man lärt sig metoderna i en av dessa så kan man i princip jobba med resten. Metodnamn återkommer. Att identifiera saker som en programmerare bör kunna och upprepa det är viktigt. Men det är inte läsbart för de som är vana vid att läsa dagstidningar

Det går ganska snabbt (10 minuter) och granska någons kod och kunna se hur långt utvecklaren kommer innan den sitter i skiten.

En telefonbok, där kan man lägga till hur mycket nummer som helst, det skalar. Kod bör anamma teknik från det, inte skrivas som en novell.

Permalänk
Medlem
Skrivet av klk:

En programmerare måste lära sig vårda sin kod och det gör man inte med verktyg som clang-format, det tar också bort kreativitet i hur man kan skriva kod för att göra den mer eller mindre hanterbar.

Jag håller inte alls med dig om detta. Kreativiteten i kodning (tycker jag) kommer från problemlösningen och sättet att uttrycka lösningen(exempelvis for/while/iterator-funktioner) inte hur man väljer att strukturera meningslösa whitespace-tecken. Om man har olika preferenser så använd andra formatter-inställningar medans du arbetar och sedan kör med teamets default vid in-checkning.

Min erfarenhet är att man sparar väldigt mycket meningslös review-tid om man kör en formatter och alla gör misstag förr eller senare så alla drar nytta av detta.

Skrivet av klk:

När du skriver till mig: "Varför tycker du att det minskar läsbarheten?"
Redan där har du kört av vägen om man kan uttrycka sig så. Ingen läser kod i större projekt, att skriva kod för att läsas är vansinne. Tyvärr görs det och där det sker går det långsamt.
När man skriver kod är det viktigt att skriva för skalbarhet, att koden är sökbar och att mönster upprepar sig.

Läsbarhet och sökbarhet utesluter inte varandra. Jag håller inte med dig på denna punkten heller. Du säger att sökbarheten är viktig men det är väl trevligt om koden du söker till är läsbar? Jag var nyligen tvungen att läsa implementationen till ett stort Go-projekt eftersom deras swagger-generator genererade felaktig dokumentation och jag är väldigt tacksam för att koden var läsbar, sökningarna hanterade framförallt LSPn så sökbarheten var mindre viktigt i just detta fallet.

Permalänk
Medlem
Skrivet av orp:

Jag håller inte alls med dig om detta. Kreativiteten i kodning (tycker jag) kommer från problemlösningen och sättet att uttrycka lösningen(exempelvis for/while/iterator-funktioner) inte hur man väljer att strukturera meningslösa whitespace-tecken. Om man har olika preferenser så använd andra formatter-inställningar medans du arbetar och sedan kör med teamets default vid in-checkning.

- Vad är en bra lösning, kan du ge exempel?
- Låt säga att du jobbar i en kodbas med + 1.000.000 rader. Vet du bra sätt på hur man får in nya utvecklare i ett sådant projekt så de blir effektiva så snabbt som möjligt.
- Hur skriver du kod så andra skall förstå vad du skrivit, måste de andra läsa din kod?

Permalänk
Medlem
Skrivet av orp:

Läsbarhet och sökbarhet utesluter inte varandra. Jag håller inte med dig på denna punkten heller. Du säger att sökbarheten är viktig men det är väl trevligt om koden du söker till är läsbar?

Jag skrev läsbar som en novell (menade normal läsning), läsbar är subjektivt och en telefonbok är läsbar för den som får reglerna förklarat för sig.
Men du läser inte en telefonbok från sida 1 till slutet, du hoppar till det du söker.
Samma med kod, kod läses inte linjärt utan mer som en graf (ett träd)

Permalänk
Medlem
Skrivet av klk:

- Vad är en bra lösning, kan du ge exempel?

Svårt att förstå vad du syftar på men jag kommer anta att du menar kodformattering för utvecklingsmiljön och du kan säkert overrida projektinställningar och sedan försäkra formatering mha en pre-commit-hook eller något liknande men detta är där kreativiteten och personlig preferens kommer in.

Skrivet av klk:

- Låt säga att du jobbar i en kodbas med + 1.000.000 rader. Vet du bra sätt på hur man får in nya utvecklare i ett sådant projekt så de blir effektiva så snabbt som möjligt.

Detta känns som en märklig fråga eftersom alla fungerar olika men bra verktygsstöd(typ LSP, debugger), bra dokumentation för att förstå arkitektur och om möjligt att inledningsvis arbeta i en avgränsad del av kodbasen men det är hur jag fungerar. Hos många kunder har varken funnits och jag har fått nöja mig med SSH-access till git-servern.

Skrivet av klk:

- Hur skriver du kod så andra skall förstå vad du skrivit, måste de andra läsa din kod?

- Välstrukturerad framförallt arkitekturmässigt, läsbart men även formaterat(notera att jag inte bryr mig om formateringen hanteras av mig eller ett verktyg).
- Undvika komplicerade lösningar där det är möjligt och kommentera komplicerade lösningar där det är oundvikligt.
- Se till att dokumentera syfte och designval i git och projektdokumentation.

Permalänk
Medlem
Skrivet av klk:

Jag skrev läsbar som en novell (menade normal läsning), läsbar är subjektivt och en telefonbok är läsbar för den som får reglerna förklarat för sig.
Men du läser inte en telefonbok från sida 1 till slutet, du hoppar till det du söker.
Samma med kod, kod läses inte linjärt utan mer som en graf (ett träd)

Jag tror inte att den vedertagna tolkningen av "läsbar kod" är att den ska vara skriven som en novell och jag är isf nyfiken på vilka programmeringsspråk du använder som ger dig möjligheten att uttrycka dig som en novell. Läsbarheten innefattar väl ett någorlunda sekventiellt flöde, någorlunda logisk gruppering och att undvik onödig komplexitet.

Permalänk
Medlem
Skrivet av orp:

Jag tror inte att den vedertagna tolkningen av "läsbar kod" är att den ska vara skriven som en novell och jag är isf nyfiken på vilka programmeringsspråk du använder som ger dig möjligheten att uttrycka dig som en novell.

Tolkade jag dig isåfall fel, kan du utveckla?
Till kanske 80% skriver jag C++ kod

Skrivet av orp:

Läsbarheten innefattar väl ett någorlunda sekventiellt flöde, någorlunda logisk gruppering och att undvik onödig komplexitet.

För mig är det svårt att förstå hur du menar. Hur skall jag skriva koden för att den skall följa det du tycker är bra och menar du att kod skall läsas för att förstå vad den gör?
C++ kod, där har man exempelvis en header fil som brukar ha deklarationer av saker (lära upp kompilatorn) och en source fil där definitioner finns (det som genererar maskinkod).
Om man slipper gå in i source filen för att läsa vad koden gör tror jag de flesta är tacksamma för det. Optimalt enligt mig är att om jag kan förstå vad ett objekt hanterar för data också kan förstå metoderna endast genom att läsa dem med hjälp av lsp standarden (autocomplete i aktuellt fall).

Borde det inte vara effektivt om du använder ett objekt, du vet att objeketet är en facade eller composite objekt (två vanliga typer). Bara genom att veta det så vet du vilka metoder de har.

Permalänk
Medlem
Skrivet av klk:

För mig är det svårt att förstå hur du menar. Hur skall jag skriva koden för att den skall följa det du tycker är bra och menar du att kod skall läsas för att förstå vad den gör?

Det känns som det blandas ihop en del saker. Jag började inledde med att inte hålla med dig gällande verktyg för kodformatering och sedan uttryckte jag att jag tycker att läsbar kod är viktigt. Sedan flyttade sig diskussionen till innebörden av läsbar kod.

https://en.wikipedia.org/wiki/Computer_programming#Readabilit...

Så läsbar kod innebär mängder av saker men jag ska ge några exempel.
- Beskrivande och koncis namngivning, DÅLIG: read_the_foo_section_from_the_config(), BRA: read_foo() / read_section_foo()
- Logisk gruppering, exempelvis fopen fclose fflush är deklarerade ihop i cstdio
- Logiskt avgränsade funktioner: DÅLIG: read_and_parse_and_validate_config(), BRA: read_config() / parse_config() / validate_config()
- Någorlunda sekventiellt strukturerat, exempevis

def baz(): pass def bar(): baz() def foo(): bar()

Många av dessa sakerna kommer naturligt eftersom läsbarhet handlar om att göra det lätt för sig själv och medmänniskor(och inte maskiner) att förstå koden när dom läser den. Brainf*** är ett exempel på ett språk med dålig läsbarhet by design.

Skrivet av klk:

Om man slipper en gå in i source filen för att läsa vad koden gör tror jag de flesta är tacksamma för det. Optimalt enligt mig är att om jag kan förstå vad ett objekt hanterar för data också kan förstå metoderna endast genom att läsa dem med hjälp av lsp standarden (autocomplete i aktuellt fall).

Så klart men läsbarhet är framförallt för dom som inte har något alternativ till att läsa koden. Om du inte har läsbar kod så kanske det inte finns doc-string till metoden som LSPn kan presentera vid autocomplete eller dåligt beskrivna parametrar så du kanske inte vet hur du ska använda metoden vid autocomplete och i vissa fall så kanske inte metoden beter sig som förväntat och du måste läsa koden för att förstå varför. Alla dessa fallen tjänar på läsbar kod.

Permalänk
Medlem
Skrivet av orp:

Det känns som det blandas ihop en del saker. Jag började inledde med att inte hålla med dig gällande verktyg för kodformatering och sedan uttryckte jag att jag tycker att läsbar kod är viktigt. Sedan flyttade sig diskussionen till innebörden av läsbar kod.

Angående läsbarhet. Kod är ofta olika saker, här är ett exempel på kod med logghantering där själva logghanteringen inte fyller någon funktion för att förstå koden.
Vad tycker du om att placera koden ute i marginalen för att den inte skall kladda ner resten?

LOG_DEBUG( gd::log::tag("option") << "active option = " << poptions_->name() << " and number of read options is = " << poptions_->size() ); // ## Add logger if argument for that is passed if( PROPERTY_Get("logging").is_true() == true ) { auto [bOk, string_] = LOGGING_CreateFile(); LOG_DEBUG_IF( bOk == true, "Log to file = " & string_ ); LOG_ERROR_IF( bOk == false, "Error = " & string_ ); } // ## Add csv logger if argument for that is passed if( (*poptions_)["logging-csv"].is_true() == true ) { auto [bOk, string_] = LOGGING_CreateCsvFile(); LOG_DEBUG_IF( bOk == true, "Log to csv file = " & string_ ); LOG_ERROR_IF( bOk == false, "Error = " & string_ ); }

Permalänk
Medlem
Skrivet av klk:

Angående läsbarhet. Kod är ofta olika saker...

Detta får du gärna förtydliga, vad menar du med att "kod ofta är olika saker"?

Skrivet av klk:

Vad tycker du om att placera koden ute i marginalen för att den inte skall kladda ner resten?

LOG_DEBUG( gd::log::tag("option") << "active option = " << poptions_->name() << " and number of read options is = " << poptions_->size() ); // ## Add logger if argument for that is passed if( PROPERTY_Get("logging").is_true() == true ) { auto [bOk, string_] = LOGGING_CreateFile(); LOG_DEBUG_IF( bOk == true, "Log to file = " & string_ ); LOG_ERROR_IF( bOk == false, "Error = " & string_ ); } // ## Add csv logger if argument for that is passed if( (*poptions_)["logging-csv"].is_true() == true ) { auto [bOk, string_] = LOGGING_CreateCsvFile(); LOG_DEBUG_IF( bOk == true, "Log to csv file = " & string_ ); LOG_ERROR_IF( bOk == false, "Error = " & string_ ); }

Nu har jag än en gång svårt med att förstå vart du vill komma. Jag tycker självklart indenteringsnivåer ska hållas eftersom det ingår i läsbar kod och jag tycker att loggraderna fyller ett syfte. Ditt exempel försämrar läsbarheten och koden hade fått -2 i en review av mig och en kommentar som bett dig fixa indenteringen(manuellt eller med clang-format).

Om du däremot väljer att formatera det såhär på din egen dator fram tills review, det hade jag inte kunnat bry mig mindre om.

Permalänk
Medlem

Jag kommer nog avsluta min del eftersom det känns aningen urspårat, jag ville framförallt bemöta dina påstående om automatiserad kodformatering och läsbarhet. Hela denna diskussionen är för övrigt OT och jag ber om ursäkt till TS.

Här är en recap med vad som känns märkligt så kanske det ger ett annat perspektiv på våra senaste inlägg...

Citat:

En programmerare måste lära sig vårda sin kod och det gör man inte med verktyg som clang-format, det tar också bort kreativitet i hur man kan skriva kod för att göra den mer eller mindre hanterbar.

Du påstår att automatisk kodformatering skulle reducera kreativa aspekter av kodning.

Citat:

När du skriver till mig: "Varför tycker du att det minskar läsbarheten?"
Redan där har du kört av vägen om man kan uttrycka sig så. Ingen läser kod i större projekt, att skriva kod för att läsas är vansinne. Tyvärr görs det och där det sker går det långsamt.
När man skriver kod är det viktigt att skriva för skalbarhet, att koden är sökbar och att mönster upprepar sig.

Du besvarar inte frågan om varför du antar att automatiskt formaterad kod minskar läsbarheten för att direkt gå över till att poängtera sökbar kod är viktig, vilket får det att låta som att läsbarheten är mindre viktig.

Citat:

- Vad är en bra lösning, kan du ge exempel?
- Låt säga att du jobbar i en kodbas med + 1.000.000 rader. Vet du bra sätt på hur man får in nya utvecklare i ett sådant projekt så de blir effektiva så snabbt som möjligt.
- Hur skriver du kod så andra skall förstå vad du skrivit, måste de andra läsa din kod?

Sedan drar du igång med vilseledande frågor istället för att besvara på tidigare frågorna.

Jag kommer ge mig här eftersom vi går i cirklar och ockuperar tråden med OT diskussioner.

Permalänk
Medlem
Skrivet av orp:

Detta får du gärna förtydliga, vad menar du med att "kod ofta är olika saker"?

I C++ är det mycket, du har ibland kod för att hantera olika optimeringar, olika hårdvara, olika operativsystem och skrivs generell kod har man ofta mycket mer som körs i debug läge.
Förutom det så behöver kod kommenteras, svår kod har mycket kommentarer.

Skrivet av orp:

Jag tycker självklart indenteringsnivåer ska hållas eftersom det ingår i läsbar kod och jag tycker att loggraderna fyller ett syfte.

Vilka regler finns för "läsbar kod"? Och vad fyller loggning för poäng för applikationens funktionalitet.

Loggning används normalt bara för att kunna se problem och då har applikationen redan kraschat.

Permalänk
Medlem
Skrivet av klk:

I C++ är det mycket, du har ibland kod för att hantera olika optimeringar, olika hårdvara, olika operativsystem och skrivs generell kod har man ofta mycket mer som körs i debug läge.
Förutom det så behöver kod kommenteras, svår kod har mycket kommentarer.

Hur relaterar detta till något i diskussionen som du och jag haft gällande kodformaterare?

Skrivet av klk:

Vilka regler finns för "läsbar kod"?

Jag trodde att jag var tydlig med att det finns inte hårda regler utan allt som hjälper oss människor att lättare förstå koden bidrar till läsbar kod. Wikipedia artikeln länkar till ett gammalt forskningspapper som innehåller några riktlinjer, vissa kommer med sunt förnuft som att inte använda random bokstäver som variabelnamn.

Skrivet av klk:

Och vad fyller loggning för poäng för applikationens funktionalitet. Loggning används normalt bara för att kunna se problem och då har applikationen redan kraschat.

Nu trollar du... Loggning används för att ge oss en inblick i körningen utan att introduceras något invasivt som en debugger. Servermjukvara ger sin huvudsakliga operational feedback i loggar. Utöver detta så vet du väl om att man kan hantera fel? Om exempelvis Discord tappar anslutning(ett fel) så krashar inte Discord utan Discord hanterar felet och visar ett disconnect:at state som försöker återansluta användaren.

Permalänk
Medlem
Skrivet av orp:

Hur relaterar detta till något i diskussionen som du och jag haft gällande kodformaterare?

Skrivet av orp:

Nu trollar du...

Enda gången någon annan kommer läsa koden är om koden måste uppdateras/förändras eller behöver rättas.

Programmerare läser inte kod, de skannar kod

Vad du ser i mitt exempel är kod som är skriven för att bli skannad. Att utvecklare snabbt skall få en uppfattning om var de skall leta.

När utvecklaren väl hittat området då börjar utvecklaren läsa kod, när det sker spelar formateringen mindre roll. I princip varenda utvecklare idag har en skärm som klarar att visa mer än 80 tecken i bredd.

formateras text till 80 tecken är det mycket svårare att skanna kod, 100 teckens bredd påverkar, sedan påverkar det självklart mindre men om man sätter 120 tecken kan man lika gärna strunta i gräns

Permalänk
Medlem

Nu håller du på med mentalgymnastik...

Skrivet av klk:

Enda gången någon annan kommer läsa koden är om koden måste uppdateras/förändras eller behöver rättas.

Här använder du läser för att beskriva en stor del(>50%) av all programmering.

Skrivet av klk:

Programmerare läser inte kod, de skannar kod

Här säger du att programmerare INTE läser och använder "skannar" som är samma sak som att läsa.

Det du möjligen kan hävda är att det finns en skillnad mellan att lära sig koden utantill och skanna men blanda INTE ihop det med läsning. Läsningen är ju hur vi konsumerar texten och läsbarheten är ett mått på hur bekvämt det är för vår hjärna att konsumera texten inte hur länge vi lägger det på minnet men som sagt du håller mest på med mentalgymnastik.

Skrivet av klk:

När utvecklaren väl hittat området då börjar utvecklaren läsa kod, när det sker spelar formateringen mindre roll. I princip varenda utvecklare idag har en skärm som klarar att visa mer än 80 tecken i bredd.

formateras text till 80 tecken är det mycket svårare att skanna kod, 100 teckens bredd påverkar, sedan påverkar det självklart mindre men om man sätter 120 tecken kan man lika gärna strunta i gräns

Min laptop 13" med förstorad text så att den ska vara bekväm att läsa klarar inte att rendera mer än 80 tecken om jag vill ha två terminaler bredvid varandra.

Ett annat exempel är ju vad som är bekvämt för ögonen att läsa och jag tycker att där går en "gräns" kanske inte vid 80 men definitivt en "gräns". Här är ett exempel från Outlook på min ultra wide monitor och by default så gör inte den någon formatering så paragraf 1 är oformaterad medans paragraf 2 är formaterad till 80. Personligen läser jag hellre paragraf 2.

Permalänk
Medlem
Skrivet av orp:

Här använder du läser för att beskriva en stor del(>50%) av all programmering.

Nej det är inte samma men om man inte lärt sig tekniker att hantera kod kan det vara svårt att förstå.

Programmering är ett stort område, det skiljer mycket på hur kod skrivs beroende på vem och vad för typ av programmering som görs.

Exempelvis så en som skriver deklarativ kod, där är tänket nästan det motsatta mot de som fokuserar på imperativ kod.
Det här behöver man förstå. För om en utvecklare som skriver deklarativ kod gör det i lösningar med imperativa generella lösningar, då förstörs koden omedelbart.

Jag har vart i denna typ av diskussioner många gånger tidigare. En del kopplar omedelbart medan andra inte gör det. Ibland måste man lära sig den hårda vägen och en teknik som fungerat någorlunda är att ge en person som tror den "vet" en ganska knepig uppgift där man vet att personen kommer trassla till det. Det går nämligen inte att lösa en hel del utan bryta isär delarna, vissa områden har så avancerade domäner att utvecklare omöjligt kan lära sig dem och så vidare.

Kan låta kaxigt men jag har själv suttit i skiten precis som så många andra och fått lära mig. Vem som helst kan lära sig skriva kod i något språk, på mindre än ett år eller ibland månad så kan man göra saker i språk. Det är lätt
Det är däremot inte lätt att lära sig hantera stora mängder kod, det tar många år och man blir aldrig fullärd.

Permalänk
Medlem
Skrivet av orp:

Min laptop 13" med förstorad text så att den ska vara bekväm att läsa klarar inte att rendera mer än 80 tecken om jag vill ha två terminaler bredvid varandra.

Och med den utrustningen har du inte en chans mot en som exempelvis sitter med 3 stycken 32" 4K skärmar. Jag tror att om du satt vid en 32" 4K skärm skulle du med teknik kunna dubbla din hastighet att producera bra kod.

Här har du en bra text: https://www.teamten.com/lawrence/writings/java-for-everything...
Och för att ta ett citat från texten

Citat:

Undocumented Python programs are horrendously difficult to maintain.

Hur beskriver man för en python programmerare att python som räknas som ett mycket enkelt språk också är ett av de mest svårlästa språken som finns. Utvecklare i Python skriver i princip alltid kod som måste läsas.

Skanna kod = hitta mönster

Permalänk
Medlem
Skrivet av klk:

Nej det är inte samma men om man inte lärt sig tekniker att hantera kod kan det vara svårt att förstå.

Jag vet inte vad du svarar på... är det läsa vs skanna eller om ändra existerande kod också klassas som programmering? Min poäng var att ge exempel på att du rör ihop dina egna definitioner av läsa vs skanna eller så påstår du att ändra i existerande kod inte klassas som programmering, oavsett så håller jag inte med dig.

Skrivet av klk:

Programmering är ett stort område, det skiljer mycket på hur kod skrivs beroende på vem och vad för typ av programmering som görs.

Det känns som att du än en gång rör ihop saker och börjar introducera nya påstående som inte hör till diskussionen.
Kan du vänligen enbart besvara ursprungsfrågan, vad är problematiskt med automatiserad kodformatering och hur försämrar detta läsbarheten i koden?! Kan du vänligen göra detta utan att feberyra om tekniker för att hantera stora kodbaser, programmeringsparadigm, oerfarna utvecklare, columnbredder i terminaler osv.

Skrivet av klk:

Exempelvis så en som skriver deklarativ kod, där är tänket nästan det motsatta mot de som fokuserar på imperativ kod.
Det här behöver man förstå. För om en utvecklare som skriver deklarativ kod gör det i lösningar med imperativa generella lösningar, då förstörs koden omedelbart.

Ytterligare ett irrelevant sidospår, varför blandar du nu in paradigm? Utöver det så kommer du med nya påstående. Hur förstör detta koden utöver att vissa språk möjligen inte stödjer bägge paradigmen? Kompilerar inte koden, kraschar programmet, blir det inte läsbart, vad menar du? Hur relaterar detta till att automatiskt kodformatering?

Skrivet av klk:

Jag har vart i denna typ av diskussioner många gånger tidigare. En del kopplar omedelbart medan andra inte gör det. Ibland måste man lära sig den hårda vägen och en teknik som fungerat någorlunda är att ge en person som tror den "vet" en ganska knepig uppgift där man vet att personen kommer trassla till det. Det går nämligen inte att lösa en hel del utan bryta isär delarna, vissa områden har så avancerade domäner att utvecklare omöjligt kan lära sig dem och så vidare.

Kan låta kaxigt men jag har själv suttit i skiten precis som så många andra och fått lära mig. Vem som helst kan lära sig skriva kod i något språk, på mindre än ett år eller ibland månad så kan man göra saker i språk. Det är lätt
Det är däremot inte lätt att lära sig hantera stora mängder kod, det tar många år och man blir aldrig fullärd.

Jag tror att somliga inte kopplar ditt resonemang eftersom att det är extremt spretigt och i denna paragrafen så är det otydligt vad du ens syftar på eftersom du blandar in nya ämnen i varje inlägg, från automatiskt kodformatering och läsbarhet > definitionen läsbarhet > skanna vs läsa > stora kodbaser > oerfarna utvecklare > kolumnbredder > skärmstorlekar > paradigm > python.

Skrivet av klk:

Och med den utrustningen har du inte en chans mot en som exempelvis sitter med 3 stycken 32" 4K skärmar. Jag tror att om du satt vid en 32" 4K skärm skulle du med teknik kunna dubbla din hastighet att producera bra kod.

Fortsatt irrelevant sidospår och felaktigt påstående. Det som bromsar mig är beslut kring koden (arkitektur, felsökning osv) och har inget med columnbredden att göra. Jag visade dig precis ett exempel på att jag bekvämare och snabbare läser en columnbredd kring 80 tecken en vad som kan visas på en 4K skärm och jag visade dig precis att jag även har en 4K skärm. Det känns som du borde "skanna" min svar lite mindre så slipper vi en del redundans.

Skrivet av klk:

Här har du en bra text: https://www.teamten.com/lawrence/writings/java-for-everything...
Och för att ta ett citat från texten
Hur beskriver man för en python programmerare att python som räknas som ett mycket enkelt språk också är ett av de mest svårlästa språken som finns. Utvecklare i Python skriver i princip alltid kod som måste läsas.

Än en gång känner jag att du rör till det. Varför drar du in python i det hela? Nej, jag håller inte med dig. Jag tycker att python är väldigt lätt att läsa och är svårt pga att det är extremt dynamiskt. Detta tycker jag iaf är lättläst:

if foo is not None: ...

Skrivet av klk:

Skanna kod = hitta mönster

Jo men när det som ska skannas är text så hävdar iaf jag att man måste läsa det sedan kan man läsa på olika sätt blindskift, uppläsning osv men fortfarande läsas. När du "skannar" så letar du efter någon textsträng(logmeddelande, nyckelord osv) och då måste du ju läsa texten annars borde du kunna nöja dig med kod i binärform och inte kräva kod som mänskligt läsbar text, inte sant?

Permalänk
Medlem
Skrivet av orp:

Kan du vänligen enbart besvara ursprungsfrågan, vad är problematiskt med automatiserad kodformatering och hur försämrar detta läsbarheten i koden?

/** --------------------------------------------------------------------------- * @brief get all values for name as variant's in list * @param stringName collected values for name * @return std::vector<gd::variant> list of variants with values from name */ std::vector<gd::variant> options::get_variant_all( const std::string_view& stringName ) const { assert( stringName.empty() == false ); auto values_ = m_argumentsValue.get_argument_all( stringName ); // get list with argument't auto variants_ = gd::argument::arguments::get_variant_s( values_ ); // convert list with argument's to list of variant's return variants_; }

/** --------------------------------------------------------------------------- * @brief Read uuid from uuid formated string * Supported formats are `00000000000000000000000000000000`, `00000000-0000-0000-0000-000000000000` * or `{00000000-0000-0000-0000-000000000000}`. * @param puBegin start of uuid formated string value * @param puEnd end of uuid formated string value * @param puSet uuid buffer for converted hex string */ inline void uuid::read_s( const value_type* puBegin, const value_type* puEnd, value_type* puSet ) { auto uLength = puEnd - puBegin; assert( uLength == 32 || uLength == 36 || uLength == 38 ); if( uLength == 32 ) { for( ; puBegin != puEnd; puBegin += 2 ) { assert( *puBegin < sizeof(m_pHexValue_s) ); assert( *(puBegin + 1) < sizeof(m_pHexValue_s) ); *puSet = m_pHexValue_s[*puBegin] << 4; assert( m_pHexValue_s[*puBegin] != 0 || *puBegin == '0' ); *puSet += m_pHexValue_s[*(puBegin + 1)]; assert( m_pHexValue_s[*(puBegin + 1)] != 0 || *(puBegin + 1) == '0' ); puSet++; } } else { if( uLength == 38 ) { puBegin++; puEnd--; } while( puBegin != puEnd ) { if( *puBegin != '-' ) { assert( *puBegin < sizeof( m_pHexValue_s ) ); assert( *(puBegin + 1) < sizeof( m_pHexValue_s ) ); *puSet = m_pHexValue_s[*puBegin] << 4; assert( m_pHexValue_s[*puBegin] != 0 || *puBegin == '0' ); *puSet += m_pHexValue_s[*(puBegin + 1)]; assert( m_pHexValue_s[*(puBegin + 1)] != 0 || *(puBegin + 1) == '0' ); puSet++; puBegin += 2; } else { assert( (puEnd - puBegin) == 28 || (puEnd - puBegin) == 23 || (puEnd - puBegin) == 18 || (puEnd - puBegin) == 13 ); puBegin += 1; } } } }

/// 256 word values with bits set to mark different character classes used in parse logic /// 0x0020 = CHAR_GROUP_DECIMAL | CHAR_GROUP_SCIENTIFIC /// 0x04E2 = CHAR_GROUP_ALNUM | CHAR_GROUP_SCIENTIFIC | CHAR_GROUP_HEX | CHAR_GROUP_DECIMAL | CHAR_GROUP_DIGIT (number) /// 0x0404 = CHAR_GROUP_ALNUM | CHAR_GROUP_ALPHABET /// 0x0444 = CHAR_GROUP_ALNUM | CHAR_GROUP_HEX | CHAR_GROUP_ALPHABET /// 0x04E4 = CHAR_GROUP_ALNUM | CHAR_GROUP_SCIENTIFIC | CHAR_GROUP_HEX | CHAR_GROUP_DECIMAL | CHAR_GROUP_ALPHABET /// 0x0010 = CHAR_GROUP_QUOTE (quote) constexpr uint16_t puCharGroup_g[0x100] = { // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,0x0000,0x0001,0x0000,0x0000,0x0000, /* 0x00-0x0F */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0x10-0x1F */ 0x0001,0x0000,0x0010,0x0000,0x0000,0x0000,0x0000,0x0010,0x0000,0x0001,0x0008,0x0008,0x0000,0x0008,0x00A0,0x1008, /* 0x20-0x2F ,!,",#,$,%,&,',(,),*,+,,,-,.,/ */ 0x04E2,0x04E2,0x04E2,0x04E2,0x04E2,0x04E2,0x04E2,0x04E2,0x04E2,0x04E2,0x0000,0x0000,0x0008,0x0008,0x0008,0x0000, /* 0x30-0x3F 0,1,2,3,4,5,6,7,8,9,:,;,<,=,>,? */ 0x0000,0x0444,0x0444,0x0444,0x0444,0x04E4,0x0444,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404, /* 0x40-0x4F @,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O */ 0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0008,0x1000,0x0000,0x0008,0x0008, /* 0x50-0x5F P,Q,R,S,T,U,V,W,X,Y,Z,[,\,],^,_ */ 0x0000,0x0444,0x0444,0x0444,0x0444,0x04E4,0x0444,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404, /* 0x60-0x6F `,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o */ 0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0x70-0x7F p,q,r,s,t,u,v,w,x,y,z,{,|,},~*/ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0x80-0x8F */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0x90-0x9F */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0xA0-0xAF */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0xB0-0xBF */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0xC0-0xCF */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0xD0-0xDF */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0xE0-0xEF */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0xF0-0xFF */ };

Permalänk
Medlem
Skrivet av klk:

/** --------------------------------------------------------------------------- * @brief get all values for name as variant's in list * @param stringName collected values for name * @return std::vector<gd::variant> list of variants with values from name */ std::vector<gd::variant> options::get_variant_all( const std::string_view& stringName ) const { assert( stringName.empty() == false ); auto values_ = m_argumentsValue.get_argument_all( stringName ); // get list with argument't auto variants_ = gd::argument::arguments::get_variant_s( values_ ); // convert list with argument's to list of variant's return variants_; }

/** --------------------------------------------------------------------------- * @brief Read uuid from uuid formated string * Supported formats are `00000000000000000000000000000000`, `00000000-0000-0000-0000-000000000000` * or `{00000000-0000-0000-0000-000000000000}`. * @param puBegin start of uuid formated string value * @param puEnd end of uuid formated string value * @param puSet uuid buffer for converted hex string */ inline void uuid::read_s( const value_type* puBegin, const value_type* puEnd, value_type* puSet ) { auto uLength = puEnd - puBegin; assert( uLength == 32 || uLength == 36 || uLength == 38 ); if( uLength == 32 ) { for( ; puBegin != puEnd; puBegin += 2 ) { assert( *puBegin < sizeof(m_pHexValue_s) ); assert( *(puBegin + 1) < sizeof(m_pHexValue_s) ); *puSet = m_pHexValue_s[*puBegin] << 4; assert( m_pHexValue_s[*puBegin] != 0 || *puBegin == '0' ); *puSet += m_pHexValue_s[*(puBegin + 1)]; assert( m_pHexValue_s[*(puBegin + 1)] != 0 || *(puBegin + 1) == '0' ); puSet++; } } else { if( uLength == 38 ) { puBegin++; puEnd--; } while( puBegin != puEnd ) { if( *puBegin != '-' ) { assert( *puBegin < sizeof( m_pHexValue_s ) ); assert( *(puBegin + 1) < sizeof( m_pHexValue_s ) ); *puSet = m_pHexValue_s[*puBegin] << 4; assert( m_pHexValue_s[*puBegin] != 0 || *puBegin == '0' ); *puSet += m_pHexValue_s[*(puBegin + 1)]; assert( m_pHexValue_s[*(puBegin + 1)] != 0 || *(puBegin + 1) == '0' ); puSet++; puBegin += 2; } else { assert( (puEnd - puBegin) == 28 || (puEnd - puBegin) == 23 || (puEnd - puBegin) == 18 || (puEnd - puBegin) == 13 ); puBegin += 1; } } } }

/// 256 word values with bits set to mark different character classes used in parse logic /// 0x0020 = CHAR_GROUP_DECIMAL | CHAR_GROUP_SCIENTIFIC /// 0x04E2 = CHAR_GROUP_ALNUM | CHAR_GROUP_SCIENTIFIC | CHAR_GROUP_HEX | CHAR_GROUP_DECIMAL | CHAR_GROUP_DIGIT (number) /// 0x0404 = CHAR_GROUP_ALNUM | CHAR_GROUP_ALPHABET /// 0x0444 = CHAR_GROUP_ALNUM | CHAR_GROUP_HEX | CHAR_GROUP_ALPHABET /// 0x04E4 = CHAR_GROUP_ALNUM | CHAR_GROUP_SCIENTIFIC | CHAR_GROUP_HEX | CHAR_GROUP_DECIMAL | CHAR_GROUP_ALPHABET /// 0x0010 = CHAR_GROUP_QUOTE (quote) constexpr uint16_t puCharGroup_g[0x100] = { // 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, A, B, C, D, E, F 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0001,0x0001,0x0000,0x0001,0x0000,0x0000,0x0000, /* 0x00-0x0F */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0001,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0x10-0x1F */ 0x0001,0x0000,0x0010,0x0000,0x0000,0x0000,0x0000,0x0010,0x0000,0x0001,0x0008,0x0008,0x0000,0x0008,0x00A0,0x1008, /* 0x20-0x2F ,!,",#,$,%,&,',(,),*,+,,,-,.,/ */ 0x04E2,0x04E2,0x04E2,0x04E2,0x04E2,0x04E2,0x04E2,0x04E2,0x04E2,0x04E2,0x0000,0x0000,0x0008,0x0008,0x0008,0x0000, /* 0x30-0x3F 0,1,2,3,4,5,6,7,8,9,:,;,<,=,>,? */ 0x0000,0x0444,0x0444,0x0444,0x0444,0x04E4,0x0444,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404, /* 0x40-0x4F @,A,B,C,D,E,F,G,H,I,J,K,L,M,N,O */ 0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0008,0x1000,0x0000,0x0008,0x0008, /* 0x50-0x5F P,Q,R,S,T,U,V,W,X,Y,Z,[,\,],^,_ */ 0x0000,0x0444,0x0444,0x0444,0x0444,0x04E4,0x0444,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404, /* 0x60-0x6F `,a,b,c,d,e,f,g,h,i,j,k,l,m,n,o */ 0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0404,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0x70-0x7F p,q,r,s,t,u,v,w,x,y,z,{,|,},~*/ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0x80-0x8F */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0x90-0x9F */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0xA0-0xAF */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0xB0-0xBF */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0xC0-0xCF */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0xD0-0xDF */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0xE0-0xEF */ 0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000,0x0000, /* 0xF0-0xFF */ };

Tack för svaret! Det handlar alltså om att standardinställningarna inte formaterar somliga scenarion korrekt som dina asserts och documentationen/strukturen för lookup tables.

Gällande asserterna så tror jag att det ska gå att specificera individuella indenteringsregler för macros(inget som jag testat själv) och för lookup tables så kan du enbart lägga en kommentar med

// clang-format off

så kommer clang-format enbart ignorera nästa uttryck.

Permalänk
Medlem
Skrivet av orp:

Tack för svaret! Det handlar alltså om att standardinställningarna inte formaterar somliga scenarion korrekt som dina asserts och documentationen/strukturen för lookup tables.

Ja eller för att beskriva så är det framförallt två problem med att formatera kod.
1) Programmeraren slutar fundera över koden som sådan, hur man kan laborera med kod för att göra den tydligare och lättare att arbeta it. Exempelvis så 80 teckens max bredd, det är extremt och där är det väldigt svårt att skriva kod utan att tvinga andra utvecklare att läsa koden.
2) Man kan "råka" formatera om stora mängder kod och sedan kan det vara mycket jobbigt att backa.

Det finns betydligt mer trick än bara hur kod kan skrivas för att lättare hantera stora mängder men nästan alla dessa förstörs med att formatera.

Personligen så delar jag alltid in kod i deklarativ domän kod och imperativ generell kod. Kod skrivs så det tydliggörs vad som är vad. Förutom det försöker jag hålla principerna med tre typer av klasser. Facade, container och value. Containers och Value klasser tror jag inte är ett pattern men jag brukar kalla dem så, Container är en lista med objekt och value och det är egentligen ett objekt som skall fungera som en primitiv typ.
Metoder i facade klasser namnges på ett speciellt sätt. Med denna teknik kan man med en schematisk bild över dataflödet i en applikation med flera miljoner rader kod få nya utvecklare att bli produktiva på en dag. De behöver inte läsa koden för att förstå den.
Jag kan också gå in i kod jag skrivit för kanske 10 år sedan och förstå, när man följler sådana här mönster blir det så mycket enklare att producera mängder med kod och det blir roligare också. Utvecklare slipper sitta och memorera variabler, metodnamn och annat. Denna typ av kod fungerar också väldigt bra med autocomplete och AI. AI fattar direkt och blir en väldigt stor hjälp.

Skrivet av orp:

Gällande asserterna så tror jag att det ska gå att specificera individuella indenteringsregler för macros(inget som jag testat själv) och för lookup tables så kan du enbart lägga en kommentar med

// clang-format off

så kommer clang-format enbart ignorera nästa uttryck.

Det blir för jobbigt (har varit med och testat den tekniken med att stänga av formatering)
Normalt brukar jag lägga assert runt 100 tecken ut i marginalen och kommenterar 80 tecken. Och sätter assert på nästan allt som går att kontrollera. De som har formaterar kod brukar inte alls ha lika mycket kommentarer eller assert eftersom det blir för kladdigt.

Permalänk
Medlem
Skrivet av klk:

Personligen så delar jag alltid in kod i deklarativ domän kod och imperativ generell kod.

Du använder begreppet "deklarativ" kod på ett konstigt sätt som jag inte är bekant med.
Jag frågade tidigare och jag frågar igen - vad är det du tror att "deklarativ kod" innebär?

Permalänk
Medlem
Skrivet av klk:

1) Programmeraren slutar fundera över koden som sådan, hur man kan laborera med kod för att göra den tydligare och lättare att arbeta it. Exempelvis så 80 teckens max bredd, det är extremt och där är det väldigt svårt att skriva kod utan att tvinga andra utvecklare att läsa koden.

Jag köper inte heller att programmerare slutar att fundera över koden för att ett verktyg fångar indenteringsfel innan en reviewer väntas göra det. Detta är saker som spar tid och i förlängningen pengar.

Jag har aldrig upplevt problem med 80 kolumners bredd. Inom Linux så har det även hävdats att man bör använda 80 kolumners bredd och kod som överskrider 80 tecken indikeras som dåligt skriven kod(exempelvis för många nestade nivåer eller för många syften med en funktion osv).

Skrivet av klk:

2) Man kan "råka" formatera om stora mängder kod och sedan kan det vara mycket jobbigt att backa.

Det går att ställa in så att formateringen enbart görs på ändrade filer och du ändrar troligen inte 100 filer i stöten. Oavsett så löser git den biten ganska lätt.

Skrivet av klk:

Det finns betydligt mer trick än bara hur kod kan skrivas för att lättare hantera stora mängder men nästan alla dessa förstörs med att formatera.

Jag vet inte varför du snöar in dig på stora mängder kod. Jag arbetar oftast i kodbaser på över 1 miljon rader och upplever inga svårigheter.

Skrivet av klk:

Personligen så delar jag alltid in kod i deklarativ domän kod och imperativ generell kod.

Skrivet av Erik_T:

Du använder begreppet "deklarativ" kod på ett konstigt sätt som jag inte är bekant med.
Jag frågade tidigare och jag frågar igen - vad är det du tror att "deklarativ kod" innebär?

Jag håller med @Erik_T.

Skrivet av klk:

Kod skrivs så det tydliggörs vad som är vad. Förutom det försöker jag hålla principerna med tre typer av klasser. Facade, container och value. Containers och Value klasser tror jag inte är ett pattern men jag brukar kalla dem så, Container är en lista med objekt och value och det är egentligen ett objekt som skall fungera som en primitiv typ.
Metoder i facade klasser namnges på ett speciellt sätt. Med denna teknik kan man med en schematisk bild över dataflödet i en applikation med flera miljoner rader kod få nya utvecklare att bli produktiva på en dag. De behöver inte läsa koden för att förstå den.
Jag kan också gå in i kod jag skrivit för kanske 10 år sedan och förstå, när man följler sådana här mönster blir det så mycket enklare aätt producera mängder med kod och det blir roligare också. Utvecklare slipper sitta och memorera variabler, metodnamn och annat. Denna typ av kod fungerar också väldigt bra med autocomplete och AI. AI fattar direkt och blir en väldigt stor hjälp.

Hur hanterar du icke-objektorienterade språk?

Att en person blir produktiv i koden innebär att dom ska kunna lägga till eller förändra koden och jag tvivlar starkt på att en ny utvecklare kommer in och fixar ett race condition på sin första dag i en kodbas på flera miljoner rader pga att du valt en abstraktionsnivå med facade-pattern+namnkonvention.

Att hävda att din abstraktions nivå med facade-pattern+namnkonvention skulle göra att det blir roligare att producera kod tvivlar jag också på. När jag tänker tillbaka på ditt tidigare påstående om att kodformatering skulle skada kreativitet så skulle jag vilja hävda att ditt mönster hämmar kreativitet mer än kodformatering. Dvs du har bestämt hur koden ska skrivas och ingen annan kan använda sin kreativitet för att skriva sin implementation.

Skrivet av klk:

Det blir för jobbigt (har varit med och testat den tekniken med att stänga av formatering)

Låter märkligt. Det behövs runt 10 rader i en fil för att fixa så macroindenteringen och sedan en rad per lookup table ...

Skrivet av klk:

De som har formaterar kod brukar inte alls ha lika mycket kommentarer eller assert eftersom det blir för kladdigt.

Eller så skriver dom unit tester istället för asserter?

Permalänk
Medlem
Skrivet av orp:

Eller så skriver dom unit tester istället för asserter?

Kort svar, skall snart dela ett dokument om imperativ vs deklrativ kod.
Men det du skriver där har jag redan räknat ut, att du gillar "unit tester".

"unit tester" är bra om du vill låsa kod. Lägg märke till låsa. Koden blir alltså svårare att refaktorera och mycket tyngre att jobba med på ett flexibelt sätt.
Unit tester plockar upp felen senare och tar inte i närheten av allt (endast det utvecklare kan förutse men då brukar de ju skriva koden så koden klarar vad de kan förutse). Unit tester är som att hälla sirap i projekten och ALLT tar så mycket längre tid.

Angående linux, ja jag vet hur många linux nördar (ursäkta uttrycket) tänker. Jag jobbar också en hel del i linux och det är fantastiskt svårt för många där och skala kod. Det är enligt mig största orsaken till varför linux aldrig var ett hot mot Microsoft Windows. Microsoft hade sin storhetstid mellan strax efter 1990 - 2010 ungefär. Då producerade de fantastisk kod och hade många mycket duktiga utvecklare.
Eftersom Linux-nördar hatade allt Microsoft gjorde tog de heller inte efter bra ideer. De klarade inte att hantera stora projekt och det ser man än idag. Vanligt att det är småprojekt och där finns det massor, samma med att linux utvecklare älskar språk som RUST. Kodare skriver sin egen kod som bara de själva förstår (orkar jobba med) och koden kommer dö när de slutar underhålla den.

En utvecklare måste förstå att det är otroligt mycket svårare att läsa och underhålla annans kod än att sitta i sin egen.

Återkommer med text om imperativ och deklarativ kod

Permalänk
Medlem
Skrivet av klk:

Men det du skriver där har jag redan räknat ut, att du gillar "unit tester".

Jag har jobbat i kodbaser som inte får ha asserter påslaget annat än för testning och måste hantera felen och som kräver tester för att klara extern verifiering. Hur hade du hanterat sådana förutsättningar?

Skrivet av klk:

"unit tester" är bra om du vill låsa kod.

Nu behöver du förklara nya märkliga påstående. Hur låser ett test koden mer än en runtime-kontroll som gör motsvarande?

Skrivet av klk:

Unit tester plockar upp felen senare och tar inte i närheten av allt (endast det utvecklare kan förutse men då brukar de ju skriva koden så koden klarar vad de kan förutse). Unit tester är som att hälla sirap i projekten och ALLT tar så mycket längre tid.

Det låter som du har missförstått vad ett unit test är. Det är testnivån närmst koden som det testar så jag vet inte vad du menar med "Unit tester plockar upp felen senare" en stack frame bort? Du assertar ju på en del returvärden från funktionsanrop och då är ju dessa också en stack frame bort, inte sant?

Skrivet av klk:

Angående linux, ja jag vet hur många linux nördar (ursäkta uttrycket) tänker. Jag jobbar också en hel del i linux och det är fantastiskt svårt för många där och skala kod. Det är enligt mig största orsaken till varför linux aldrig var ett hot mot Microsoft Windows.

Nytt sidospår... nya missförstånd... precis som deklarativ vs imperativ så känns det som att du använder begreppet "skala" tvetydigt. Vad är fantastiskt svårt för folk i Linux? Vad är det som inte skalar med koden? Du kanske känner till att Linux är standard för det de flesta datorer om man bortser från persondatorer? Servrar, bilar, mobiltelefoner, kaffekokare, övervakningskameror, smarta lås osv så vad skalar inte om man kan köra det på inbyggda system och på serverkluster så vill jag iaf hävda att det inte skalar.

Skrivet av klk:

Microsoft hade sin storhetstid mellan strax efter 1990 - 2010 ungefär. Då producerade de fantastisk kod och hade många mycket duktiga utvecklare.
Eftersom Linux-nördar hatade allt Microsoft gjorde tog de heller inte efter bra ideer. De klarade inte att hantera stora projekt och det ser man än idag. Vanligt att det är småprojekt och där finns det massor, samma med att linux utvecklare älskar språk som RUST. Kodare skriver sin egen kod som bara de själva förstår (orkar jobba med) och koden kommer dö när de slutar underhålla den.

Det känns som du levt under en sten de senaste 15 åren. Jag ogillar Microsoft för att dom måste hålla en i handen och inte ger mig källkoden till att lösa mina egna problem. Jag bytte till Linux för att Windows inte klarade av(Windows klarade inte att boota efter random kraschar) en ny SSD som jag köpte för 12 år sedan.

Vad menar du med att Linux inte klara hantera stora projekt några av de största kodprojekten är ju Linuxkärnan?

Där är för övrigt väldigt stort motstånd till Rust inom Linux-communitiet så jag förstår inte vart dina fördomar kommer ifrån?

Kan du vänligen besvara frågor till dina många märkliga påstående? Jag har ställt mängder med följdfrågor till dina mängder med märkliga påståenden men du besvarar nästan inget. Det känns som du framförallt vill vara obstinat och provocerande.

Permalänk
Medlem
Skrivet av orp:

Jag har jobbat i kodbaser som inte får ha asserter påslaget annat än för testning och måste hantera felen och som kräver tester för att klara extern verifiering. Hur hade du hanterat sådana förutsättningar?

Jag hade bytt jobb. Det finns gott om arbetsplatser där gången är "så här gör vi, tig eller dra". Starkt tecken på att miljön inte fungerar.

Skrivet av orp:

Nu behöver du förklara nya märkliga påstående. Hur låser ett test koden mer än en runtime-kontroll som gör motsvarande?

Tror du det går att skriva tester som fångar upp potentiella buggar? I tidigare inlägg skrev du om trådar, jag lovar att du har mycket svårt att hitta någon kodare som är så skicklig att den kan skriva test som testar av trådhantering (race conditions).
Unit tester kostar mycket mer än de smakar och det är svårt att skriva bra sådana tester. Tar också för lång tid innan andra utvecklare märker om de gjort fel.
"assert" smäller med en gång och kodare kan rätta, förutom det förespråkar jag regresionstester. Där arbetar du med produktionskod och behöver inte bygga något extra och dessutom är det ger det bättre feedback.

Skrivet av orp:

Nytt sidospår... nya missförstånd... precis som deklarativ vs imperativ så känns det som att du använder begreppet "skala" tvetydigt. Vad är fantastiskt svårt för folk i Linux?

Vad är det som inte skalar med koden? Du kanske känner till att Linux är standard för det de flesta datorer om man bortser från persondatorer? Servrar, bilar, mobiltelefoner, kaffekokare, övervakningskameror, smarta lås osv så vad skalar inte om man kan köra det på inbyggda system och på serverkluster så vill jag iaf hävda att det inte skalar.

Normalt när man utvecklar program så hanterar programmet en domän (ämnesområde). Denna domän kan vara mer eller mindre svår. Lättare databassystem, där är det kanske ok om utvecklare också lär sig domänen men det är är sällan kul, utvecklare gillar att koda.
Svårare domäner är ibland omöjliga. Kan bero på många saker. Så hur skriver du program som hjälper till där domänen är så svår att det är omöjligt att hitta programmerare som kan domänen?
Svar: Separera domän från kod så mycket som bara går. Och domänen kan då få en deklarativ lösning. Målet med deklarativ kod är att skriva så lite kod som möjligt, helst ingen kod alls.
Det är motsatsen till generella imperativa lösningar. Två helt olika saker

Permalänk
Medlem
Skrivet av orp:

Vad menar du med att Linux inte klara hantera stora projekt några av de största kodprojekten är ju Linuxkärnan?

Vet du något mer och det projektet är kanske inte riktigt standard, samt att det har många som övervakar och strikta regler hur kod får skrivas.

Skrivet av orp:

Där är för övrigt väldigt stort motstånd till Rust inom Linux-communitiet så jag förstår inte vart dina fördomar kommer ifrån?

Det tror jag säkert men det är inte samma sak som att alla är det och de flesta projekt jag sett i RUST (alla) är primärt för linux/mac.
Också tolkat att det är personer som ofta gillar vim eller liknande.