Plaats een reactie

Je mail wordt niet openbaar getoond. Het wordt enkel gebruik voor contact of notificatie vanuit het beheer.

🗨️ Wat vind jij? Stel direct je vraag of geef je mening – zonder registratie. Je reactie zet het topic weer bovenaan bij 'Laatste posts' en trekt snel nieuwe reacties aan🔥. Mocht je als vaste bezoeker willen reageren, dan kun je je ook registreren.

Bevestig dat je geen robot bent door de volgende vragen te beantwoorden.

Noor heeft 10 knikkers. Ze verliest er 4 in het gras. Hoeveel heeft ze er nog?

Antwoord: (vul een getal in)

Er zitten 5 vogels op een hek. Twee vliegen weg. Hoeveel blijven er zitten?

Antwoord: (vul een getal in)

Weergave uitklappen Voorafgaande berichten: Java 7

Re: Java 7

door Schwartz » di 01 dec 2009, 19:21

IF a=10 then begin a:=a+1;software;end;

IF a=11 then begin software end;

is andere software dan

CASE A OF

10: a:=A+1;software;

11:software;

END;

en de compiler mag dit niet fout doen....

de compiler mag niet mee gaan zitten programmeren....

De delphi compiler test nu bij een case uit of alle waarden uniek zijn, dit is niet het geval bij de if;

en er is minimaal 1 case verplicht, dit vind ik een nadeel inzake programmatie (ik kan met eigen commandos software verzamelen voor in een case constructie).

Re: Java 7

door Cycloon » di 01 dec 2009, 18:45

Schwartz schreef:@cycloon

Zo logisch is dat niet, de compiler kan bij een case anders gaan handelen en de test constructie optimaliseren omdat alle waarden vastliggen.


Als je gelijkaardige testen uitvoert dan zijn alle mogelijkheden uiteraard ook vooraf bekend in je if/else constructie. Ook zal een bepaalde waarde in het register gehaald worden (die om te vergelijken) en een beetje goede compiler zou zelf moeten opmerken dat deze waarde tot de laatste else in het register moet blijven. Voor de rest zullen de instructies voor de processor grotendeels gelijklopend zijn.

Re: Java 7

door Schwartz » di 01 dec 2009, 18:32

@cycloon

Zo logisch is dat niet, de compiler kan bij een case anders gaan handelen en de test constructie optimaliseren omdat alle waarden vastliggen.

Ook heeft men de testwaarde vast staan per test.

Vond het opmerkelijk dat delphi4 (pascal) de case weglaat die geen software omvat, terwijl er wel begin;end instaat.

Deze begin en end wordt waarschijnlijk eerst verwerkt.

Ook het snelheidsverschil tussen de oude en de nieuwe computer valt erg op..

de processor van de nieuwe draait op 3.2 en de oude op 2.8..

14% sneller ongeveer...

maar de testwerking is nu gemiddeld 24 cycli was eerst. 57 cycli...

Kan men zien dat de nieuwe processoren beduidend beter presteren....

Voor het afvangen van toetsdrukken hoeft men geen hash toe te passen want een paar cycli meer maakt dan niets uit....

Wel als men vele commandos af moet vangen.

Re: Java 7

door Cycloon » di 01 dec 2009, 16:56

Uiteraard zou dat nauwelijks verschil mogen geven, uiteindelijk worden beide situaties omgeschreven naar spronginstructies voor de processor.

Re: Java 7

door Schwartz » ma 30 nov 2009, 23:53

Heb vorige geedit maar er is iets fout gegaan:

De editing is niet verwerkt en nu kan ik het niet meer editen.

De case en if is net zo snel.

De compiler heeft de lege case testen namelijk niet opgenomen waardoor er een aanzienlijk snelheidsverschil ontstond.

Haal nu een snelheid van 15 seconden voor beide op een moderne computer.

Re: Java 7

door Schwartz » ma 30 nov 2009, 23:26

Heb vandaag even een meting gedaan in delphi4 pascal:

2 giga aan testen op een 2.8 Ghz processor.

De if testing kwam op 41 seconden

En de case constructie kwam uit op 5 seconden.

Getest bij 20 ingangen.

Betekent dat de case met de testconstructie erbij per test gemiddeld maar 7 processorcycli nodig heeft.

Re: Java 7

door Cycloon » ma 30 nov 2009, 14:11

Geamortiseerd, wat is dat?
Om even een vrij simpel voorbeeld te nemen:

Een vector wordt in het geheugen gereserveerd als een tabel van een bepaalde grootte (voor het gemak nemen we even 10 groot). Wanneer je elementen in de vector steekt gaat dit even snel als bij een gewone tabel, namelijk O(1). Wanneer je echter een elfde element op de vector probeert te steken moet er een grotere tabel gemaakt worden en moet je alle elementen kopiëren naar de nieuwe tabel, dit is maar O(n). Als je echt alles uitmiddelt over de 11 elementen krijg je iets in de ordegrootte van O(2) performantie voor het geheel. We kunnen dus zeggen dat de geamortiseerde performantie van een vector O(1) blijft.

Nu bij hashes heb je een gelijkaardige situatie. In sommige gevallen zullen er meerdere elementen per hashentry zitten. Je zou er van kunnen uitgaan dat alle elementen in dezelfde hashingang komen en dan zou opzoeken O(n) zijn (namelijk gewoon sequentieel doorlopen). Maar dan zouden alle andere op te zoeken strings slechts O(1) zijn (vermits daar geen entries meer zijn). Als we dit nu weer uitmiddelen krijg je een geamortiseerde zoeksnelheid van O(1).

Hopelijk kan je een beetje volgen? :eusa_whistle:

Re: Java 7

door Nvt » ma 30 nov 2009, 11:50

Hash functies zijn geamortiseerd...
Geamortiseerd, wat is dat?

Re: Java 7

door Schwartz » ma 30 nov 2009, 00:10

In pascal kun je ook dit doen:

t:='A'

repeat;

if t='A' then begin oproep;break; endif

if t='B' then begin oproep;break; endif

if t='C' then begin oproep;break; endif

if t='D' then begin oproep;break; endif

until true;

staat beter dan nesten met else en voorkomt stacking

En ook if functieoproep()=t blijft toepasbaar en dat heeft men met case niet.

Bij een goede compiler is case sneller omdat dit geoptimaliseerd wordt, maar men zit vast aan een vaste constructie van constanten.

Er is geen functie oproep mogelijk en complexe testen zijn ook niet toepasbaar.

Dus het een en ander is afhankelijk van de situatie.

Re: Java 7

door meijuh » zo 29 nov 2009, 23:14

Beetje offtopic hierzo, kun je beter afsplitsen..

En verder een niet zo bijzondere blog, enige wat hij bespreekt is een de syntax die wat veranderd.

Lijkt me veel interessanter om te zien wat er in de JVM verandert.

Re: Java 7

door jhnbk » zo 29 nov 2009, 22:57

Ik blijf bij mijn standpunt dat van zodra je meer dan 3 if testen nodig hebt (of 3 staten in je switchen) de geschreven code een andere structuur vraagt. Door de verdere support van switches heb ik nogal het gevoel dat slecht gestructuurde code wordt aangemoedigd.
Kan je dit, eventueel met wat voorbeelden, beter uitleggen? Heb je het nu over structuur, of ook over optimalisatie en dergelijk?

Re: Java 7

door Cycloon » zo 29 nov 2009, 22:51

virtlink schreef:Bij een switch zijn alle 'keys' (mogelijke waarden) van te voren bekend. Als je hier een hashmap van maakt moet je dus een perfecte hash functie hebben om in de slechtst mogelijke situatie snel genoeg te zijn. Hoe krijg jij in Java zo'n functie ingesteld?

Een Hashmap is bijvoorbeeld ingesteld op een maximale load van 0.7. Oftewel, het kost 21% van het geheugengebruik van een switch extra door een hashmap te gebruiken (zonder overhead).

Enne... in een switch kan je de geprefereerde keus hoger in de lijst zetten. En je kan de rest afvangen met een 'default' clausule. Knappe kop die beide met een hashmap voor mekaar krijgt, nietwaar?
Hash functies zijn geamortiseerd altijd sneller dan een sequentiële doorloop van een switch constructie, zelf indien de sleutels vooraf niet bekend zijn kan je wiskundig bewijzen dat een familie van hashfuncties er voor zorgt dat de gemiddelde performantie beter zal zijn dan O(n).

De "rest" afvangen met een defaultwaarde is nauwelijks moeilijker, je hoeft enkel te controleren of een bepaalde sleutel aanwezig is. In een switch zal de defaultwaarde altijd pas na n vergelijkingen kunnen vastgesteld worden, bij een hashmap kan dit zelf vaak met slechts 1 vergelijking.

Mocht een hashmap dan toch in sommige gevallen slecht uitvallen dan kunnen we nog steeds een treemap gaan gebruiken die dmv rood/zwart-boom implementatie altijd een performantie haalt van O(lg n). Daar zit je dan te kijken met je O(n) constructie :eusa_whistle:

Nuja, ik heb nogal het gevoel dat jullie liever straightforward code zitten te kloppen die nauwelijks flexibel en efficiënt is. De implementatie die ik aandraag vraagt idd iets meer tijd om te implementeren, maar is in alle gevallen duidelijker en beter onderhoudbaar. Ik blijf bij mijn standpunt dat van zodra je meer dan 3 if testen nodig hebt (of 3 staten in je switchen) de geschreven code een andere structuur vraagt. Door de verdere support van switches heb ik nogal het gevoel dat slecht gestructuurde code wordt aangemoedigd.

Hopelijk moet ik nooit code onderhouden die door jullie geschreven is ](*,)

Re: Java 7

door virtlink » zo 29 nov 2009, 21:09

Het spijt me maar ik krijg steeds het gevoel dat je soms op iemand anders reageert dan op mij. Waar je eerst leek te reageren op een stelling dat er geen onderzoek naar het vergelijken van strings meer wordt gedaan (wie zei dat dan? ik niet dacht ik), heb je het nu ineens over een interpreter die ik niet genoemd heb.
Java is al eeuwenlang geen volledige interpreter meer. De meeste structuren worden nu ook gecompileerd (JIT compilatie). Dat argument slaat dus op niks.
Ik weet heus wel dat Java JIT gecompileerd is en dat is totaal irrelevant voor deze discussie. Mijn punt was, nogmaals: stel dat waarde 'a' (uit 317070's voorbeeld) een methodeaanroep is (zeg: geeft een random getal terug en kost 2 seconden om die te berekenen). Die compiler zal waarschijnlijk slechts eenmaal een instructie emitten waarbij de waarde van de methode wordt berekend en opgehaald, en die opgehaalde waarde dan steeds laten vergelijken in de switch. Voor meerdere if-jes is dit zeker niet het geval en wordt de methode steeds aangeroepen als deze nodig is voor de if. Dus een switch kan sneller zijn, en mijn argument slaat op deze discussie.

Over je andere argumenten: sorry maar ik verkies duidelijkheid boven het terugbrengen van het aantal regels. En dat zou elke programmeur moeten doen. Verder denk ik: veel plezier met het gebruik van een hashmap voor je 3 commando's. Waarom makkelijk doen als het moeilijk kan toch? Gebruik je nu werkelijk hashmaps voor alle stringvergelijkingen? En hoe doe je dat met de enums die ik noemde? Hoe ziet een hashmap-implementatie eruit t.o.v. hetzelfde als een switch implementatie? Hoeveel regels kost het om, in de toekomst, één commando aan je hashmap toe te voegen, en hoeveel kost het om datzelfde aan een switch toe te voegen?

Bij een switch zijn alle 'keys' (mogelijke waarden) van te voren bekend. Als je hier een hashmap van maakt moet je dus een perfecte hash functie hebben om in de slechtst mogelijke situatie snel genoeg te zijn. Hoe krijg jij in Java zo'n functie ingesteld?

Een Hashmap is bijvoorbeeld ingesteld op een maximale load van 0.7. Oftewel, het kost 21% van het geheugengebruik van een switch extra door een hashmap te gebruiken (zonder overhead).

Enne... in een switch kan je de geprefereerde keus hoger in de lijst zetten. En je kan de rest afvangen met een 'default' clausule. Knappe kop die beide met een hashmap voor mekaar krijgt, nietwaar?

Trouwens, is 317070's voorbeeld niet veel duidelijker? Vooral als je je voorstelt dat 'a' mogelijk een lange expressie zou kunnen zijn.

Re: Java 7

door 317070 » zo 29 nov 2009, 20:06

Wel; nu ziet iets waarbij verschillende condities binnen een string getest moeten worden er zo uit:

Code: Selecteer alles

String a = "abcdefg";

if(a.equals("a")){

   het_is_a();

}else if(a.equals("b")){

  het_is_b();

}else if(a.equals("c")){

   het_is_c();

}else{

   het_is_nog_iets_anders();

}
en dat wordt nu

Code: Selecteer alles

String a = "abcdefg";

switch(a){

case "a":

   het_is_a();

   break;

case "b":

   het_is_b();

   break;

case "c":

   het_is_c();

   break;

default:

   het_is_nog_iets_anders();

}
Ik vind het tweede veel duidelijker ogen, dus de opmaak vind ik zeker een pluspunt. Daarnaast is het nu ook simpeler om als het a is ook uit te voeren wat bij b,c en d staat, gewoon de break weglaten. Met een if-else structuur is zoiets minder duidelijk.

Overigens is jouw manier van programmeren (maak verschillende objecten aan met hetzelfde commando zodat je ze in een hashmap kunt gooien) wel bruikbaar, maar lang niet steeds het duidelijkst (en al zeker niet het leesbaarst als je tussen 10 objecten moet bladeren om naar de betekenis op zoek te gaan).

Re: Java 7

door Cycloon » zo 29 nov 2009, 11:37

En waarschijnlijk is een switch sneller omdat de compiler slechts eenmaal de waarde ophaalt en daarna steeds vergelijkt, terwijl vaak meerdere if-jes meerdere malen de waarde ophalen (afhankelijk van hoe je compiler optimaliseert).
Java is al eeuwenlang geen volledige interpreter meer. De meeste structuren worden nu ook gecompileerd (JIT compilatie). Dat argument slaat dus op niks.
Vooral als de code per waarde sterk verschilt loont een switch. Iemand die een switch liever vervangt door een groot aantal if-then-else clausules heeft beperkte kennis van programmeren.
In welke zin zou een switch duidelijker zijn dan een if/else structuur? Zelf qua aantal regels en opmaak heeft een switch nauwelijks/geen voordeel.
Een programma dat reageert op een beperkte verzameling commando's gebruikt een switch (met strings).
Een programma die moet reageren op bepaalde commando's kan je ook weer perfect uitwerken met extra objecten die elk voor een commando staan, of wil je alle code samenproppen in je switch constructie? En het ontwerp is simpel, je maakt een interface voor je commando en je gooit al je commando objecten in een hashmap. Je programma is makkelijk uitbreidbaar en zal bij een groot aantal commando's nog steeds vlot lopen. Ok jij hebt het over een beperkte verzameling commando's, als je maar 2-3 commando's hebt lijkt het mss overkill om zoiets te gaan doen, maar als je later wil gaan uitbreiden zal je blij zijn dat er reeds een goede structuur aanwezig was.

Er zijn zelden situaties te vinden waar een switch echt voordeel oplevert. Dat de Java implementatie nu expliciet ondersteuning biedt om een string in een switch te gebruiken moedigt enkel aan om slechte manieren te programmeren, want gebruikers denken nu omdat er ondersteuning voor is dat het waarschijnlijk wel de beste oplossing is.