Go 1

Címkék

Fontos fejlesztési mérföldkőhöz érkezett a Google Go névre hallgató programozási nyelve. A fejlesztők bejelentették a Go version 1-et, vagy röviden a Go 1-et. A Go 1 az első olyan kiadás, amely bináris is formában elérhető. Letölthető Linux, FreeBSD, OS X és Windows platformokra.

Részletek a bejelentésben.

Hozzászólások

Jobb lett volna 3-rol kezdeni a szamozast, akkor lehetne 3, 2, 1, GO! :)

Valaki homalyositson fel hogy az include-tol az import stb miert meroben vilagmegvalto dolog? Mitol tud tobbet amiert jo a meleg vizet ujra feltalalni? Egy tisztesseges forditot/extension-t (az o elvarasaikhoz merten) ha mar ugyis c like a syntax nem lett volna kezenfekvobb? (ezt mar olvastam de okosabb nem lettem : http://golang.org/doc/go_faq.html#creating_a_new_language)

Igazából a legnagyobb gyökérség, amit a C-nél ki tudtak találni az ez a header includeolgatós baromság, ami miatt manapság ott tartunk, hogy egy picit is nagyobb kódnál úgy minimum 1-2 megányi headert includeolgat be minden .c/.cpp fájl elejére, amit nyilván fel kell dolgozni.

Aztán meg összelinkelni.

----------------
Lvl86 Troll - Think Wishfully™

A C egy többé-kevésbé platformfüggetlen nem túl vastag rétegként készült az assembly fölé, kernelhekkelési célzattal. Bármiféle modulkezelést beépíteni már tökönlőtte volna ezt a célt. Az egyszerű szövegmásolás teljesen jó megoldás ilyen szinten.
----
Hülye pelikán

Továbbra sem látom be, hogy miért. Alapvetően a header fájlok szinte csak deklarációkat, makrókat tartalmaz, sokszor azokat is gyakorlatilag konstansok helyett használva. Mára ez önmagában jelentős mennyiség, ha mondjuk csak az alap C/C++ headereket meg mondjuk az éppen használt platform néhány dolgát használjuk csak. Így viszont a kód feldolgozása 90%-ban másról sem szól, mint a beincludeolt header fájlok feldolgozásáról, holott előre fordítottan sokkal-sokkal-sokkal gyorsabban is fel lehetett volna használni. Attól még ugyanúgy kell linkelni és hasonlók.

Jó példa erre (figyelembe véve az ott alkalmazott megoldás hibáit is) a Pascal.

Ezen kívül érdemes megjegyezni, hogy a C-t nagyon nem kernelhekkelésre használják ma többnyire

----------------
Lvl86 Troll - Think Wishfully™

Egyszerű rendszert akartak. A C a lehetőségek nyelve: a fordító szinte semmit nem köt meg (lásd implicit int, nem kell deklarálni a függvényeket (majd a linker megfogja), aminél ésszerűen lehet az kifejezés, pointerek szabadsága). Ez a fajta inklúdolós header a lehető legáltalánosabb megoldás, és a lehető legegyszerűbb is, már ami a fordító szemszögét nézi. Akkoriban kisebb programok voltak.
Az ADA csomagkezelése (és ha már itt tartunk, a Pythoné is) nekem is nagyon tetszik, dehát nem lehet mindent :)

"Ezen kívül érdemes megjegyezni, hogy a C-t nagyon nem kernelhekkelésre használják ma többnyire"

De mindenképpen alacsonyszintű dolgokra (beágyazott rendszerek, egyéb hardverközeli dolgok). Ahol nem, ott eltévesztették az eszközt.
----
Hülye pelikán

"nem kell deklarálni a függvényeket (majd a linker megfogja"

??? Pont, hogy a headerek tartalmazzák a deklarációkat (többnyire), hiszen, különben le se tudnád fordítani az adott C kódot, mert nem tudnád, hogy létezik ilyen vagy olyan függvény valahol a nagyvilágban.

"már ami a fordító szemszögét nézi."

Nekem a linkelés szükségességétől kezdve (mikor a csillió deklarációhoz hozzá kell keresni valamelyik tárgykódból a definíciót, ellenőrizve, hogy van-e, stb.) nem tűnik egyszerűbbnek.

"Ahol nem, ott eltévesztették az eszközt."

Akkor gyakorlatilag az user space szoftverek 98%-ánál elrontották az eszközt.

----------------
Lvl86 Troll - Think Wishfully™

A régi C szabványban (sőt, még a szabvány előtt) nem kellett deklarálni a függvényt. Meghívtad, és majd megkeresi a linker. SZÉP dolog a headerbe rakni, de tulajdonképpen tényleg felesleges, amíg a fordító rájön, hogy ez egy függvényhívás (mi más lenne), tud hívást generálni a kódba, tényleg felesleges ismerni a függvény nevét, hiszen a paraméterlistát nagyjából csak megegyezéses alapon tartották be, aztán majd jön a segfault meg a stack szétbarmolása. Igen, a C ilyen volt, nyílván ez kóklerség és gányolás, de így indult. Akkoriban ez nem volt fontos, aki kódolt az tudta, mit csinál.

Az inklúdról volt szó, és a fordítóról. Az ő szemszögéből elég egyszerű dolog ez az inklúd: bemásolja a szöveget, aztán lesz ami lesz.
A linkelés megint más tészta. De C-ben mint említettem, meglehetős szabadosság van olyan téren, hogy miről mit kell megmondani hogy hol találja, így nem látom, hogy lehetett volna ezt máshogy.

Nem tudom, milyen statisztikát nézel, de a user space jelentős része inkább a Java, C++ vonalon mozog. Az hogy sok az olyan ember, aki nem képes elhagyni a megszokott eszközt, nem azt jelenti, hogy az a jó eszköz.

http://www.tiobe.com/index.php/content/paperinfo/tpci/index.html

Nem pont ezt méri, de indikátornak nem rossz.
----
Hülye pelikán

"A linkelés megint más tészta."

Nem tudom különválasztani a fordítási (=build) folyamatból. Attól, hogy van egy rakás tárgykódom, attól még nem egy kész program. (Itt mondjuk a magyar terminológia kissé szerencsétlen, hogy a compile-t és a build-ra is fordításként hivatkozunk).

"Nem tudom, milyen statisztikát nézel, de a user space jelentős része inkább a Java, C++ vonalon mozog. "

Ilyen szempontból a C++ ugyanaz.

"Akkoriban ez nem volt fontos, aki kódolt az tudta, mit csinál."

Akkoriban nem volt fontos, hogy tudjam, hogy miért T = r^2*pi, aztán az egyetemen mégis tudni kellett, hogy az miért az. Változnak az igények.

----------------
Lvl86 Troll - Think Wishfully™

A fordítás és a linkelés a C/C++ világban elég élesen elkülönül, ezért merészelem szétválasztani őket. A build folyamat általában abból áll, hogy amit kell lefordítunk, és összelinkeljük az objecteket. Máshol nem ennyire egyértelmű, de igazából a legtöbb nyelv vagy dinamikusan tölti be a dolgokat, vagy ugyanúgy linkel, mert eleve C-re fordul.

"Ilyen szempontból a C++ ugyanaz."

Lásd alul, nagy bánatom hogy a C++ is így működik. De Stroustrupék NAGYON gondolkodnak valami értelmes modulozáson (lásd gonativeos linkemet valahol). Csak ez egy baromi nehéz kérdés.

"Akkoriban nem volt fontos, hogy tudjam, hogy miért T = r^2*pi, aztán az egyetemen mégis tudni kellett, hogy az miért az. Változnak az igények."

Fonál eleje:

"Akkoriban ez nem volt gyökérség. A nagyobb baj, hogy a C++ is átvette."

Igen, változnak az igények, én azt fejtegettem, hogy amikor a C megalakult, miért nem volt hülyeség. Azóta meg beégett az informatikába, gyakorlatilag C-n fut a világ.
----
Hülye pelikán

Szerintem elbeszélünk egymás mellett.

Értelmezzük a fordítást most úgy, hogy az összes folyamat, ami ahhoz kell, hogy a nyers forráskódból, amit a programozók pötyögtek be előáll a kész, végleges futtatható bináris.

Ennek tükrében értékeld át az egész headeres cumót.

----------------
Lvl86 Troll - Think Wishfully™

Még mindig ez a legáltalánosabb, és legkönnyebb megoldás a fordítónak (egyben). A legáltalánossal talán nem akarsz vitatkozni, a legkönnyebb pedig úgy értve, hogy a fordító beleszarik, a linkernek meg egyszerű dolga van, neveket keres. Ha már fordításkor lesni kéne, hogy mi hol van meg, az bonyolítaná a fordítást. Egy függvényhívást könnyedén le tudok fordítani anélkül, hogy ismerném a függvény törzsét.
----
Hülye pelikán

"legkönnyebb megoldás a fordítónak"

Ezt momentán 2012 környékén leszarom. Mellesleg jó kódoptimalizálót írni szerintem nagyságrenddel bonyolultabb, mint megoldani az összeszerkesztés problémáját normálisan. Persze, a mai igények dögöljenek meg, mert 40 éve valaki lusta volt normális fordítót írni.

"a linkernek meg egyszerű dolga van, neveket keres"

Jó ellenpélda a már említett TPU: az unit tartalmazta az interface-kat, nem kellett semmit se összemókolni. Breaking news: működött.

"hogy a fordító beleszarik"

Igen, kb. emiatt vannak a forward declarationokkal való szívások C-ben, C++-ban. Mert ahelyett, hogy a gép megoldotta volna magától, - ezt az egyébként nem annyira lehetetlen feladatot - inkább szívjon vele a fejlesztő.

----------------
Lvl86 Troll - Think Wishfully™

De most könyörgöm, mégis minek csinálták meg a C-t? Unaloműzésből, vagy, hogy a jövőben használják? Épp azt feszegetem, hogy az előrelátás minimális szikrája is hiányzik az egész header koncepcióból, csupán, mert a "fordító leszarja".

Nehogy már ez legyen az indok.

----------------
Lvl86 Troll - Think Wishfully™

Egy olyan megoldast vedesz, ami mar a kitalalasakor _hulyeseg_ volt, es azota senki nem vette a faradsagot, hogy az egeszet kivagja a francba, es valami normalis megoldast alkosson, ehelyett a tragyat gorgeti a C/C++ kozosseg maga elott. A C++ is csak taposta tovabb a meleg vizet, ahelyett, hogy adott volna egy ertelmes megoldast a problemara. Es a C++ az nem egy olyan baromi regi termek, hogy azt lehessen mondani: igen, akkor ott jo otletnek tunt. Mar akkoriban is voltak sokkal eletkepesebb megoldasok ugyanerre a problemara.

Egyszeruen nincs vedheto pont ebben a tortenetben.
--

Ki oda vagyik, hol szall a galamb, elszalasztja a kincset itt alant. | Gentoo Portal 

Ez a trágyagörgetés teljesen érthető dolog. Meg van írva n darab kernel C-ben, van sokmillió egyéb kód is C-ben, tele van minden include-os hekkelésekkel. Nem lehet kidobni, ahogy a Linux kernelhez sem tudsz C++-ban fejleszteni. Tehetetlensége van a dolgoknak, minél régebb óta van, annál nagyobb.

Az egy más kérdés, hogy NEM volt hülyeség a kitalálásakor. De még egy értelmes indokot nem láttam, hogy miért lett volna az. Kernelfejlesztésről beszélünk, erre találták ki a C-t. Majd pont unitokkal fog szórakozni az ember, ami egy absztrakt fogalom, a kernelfejlesztésben pedig pont, hogy közel akarunk maradni a valósághoz.
----
Hülye pelikán

Ugyanigy az egysz^Wlustak voltak forditot irni is egy fogalom. Masreszt mar fel lett sorolva egy csomo erv (bonyolultabb linkeles, gyakorlatilag minden .c fajlba definialod a strukturakat, stb. az includek eseten, forward deklaraciok szuksegessege, ami a kodolast neheziti - ebbol a szempontbol a Pascal is defektes -, stb. stb. stb. stb.

C-ben nem csak a kernelt irtak, hanem gyakorlatilag felfele is mindent C-ben kezdtek el megvalositnai. Egy programnyelvet meg a jovonek szannak, ahol legalabb 10-20 eves tavlatokban elore kell gondolkodni, amit a C-nel nagyon jol lathatoan nem tettek meg. (Es most egy egesz iparag szop vele).

Btw. a fuggveny es a valtozo is egy absztrakcio. Sot a ciklus is, de akar meg egy kosza if is felfoghato absztrakcionak.

----------------
Lvl86 Troll - Think Wishfully™

A C-t azért csinálták, hogy ne assemblyben kelljen reszelni. Az első verzió nagyjából ennyit is tudott: vékony réteg az assembly fölött. Valamekkora absztrahálás nyílván van a dologban, hiszen a platforfüggetlenség nem megy anélkül, de ha leírom, hogy
i = 2;
akkor pontosan tudom, hogy optimalizáció nélkül az egy mov ,2 lesz. Az értékadás baloldala mindig az adott kifejezés címét jelenti (tehát a tomb[i] a tomb i. elemének a címét ha baloldalon áll), a jobboldala pedig az értékét. Ez csak szintaxis. Assemblyben ezt máshogy fejezted ki, dialektustól függően []-vel, vagy anélkül, tökmindegy. C-ben az értékadáshoz viszonyított pozíció határozza meg, hogy címmel vagy értékkel dolgozunk. Ennyit a memóriacímekről és a pakolgatásról.

A C még jelenlegi formájában is olyan nyelv, hogy az ember kb szemmel tud assemblyt generálni a kódból, annyira közel van.
----
Hülye pelikán

"A C még jelenlegi formájában is olyan nyelv, hogy az ember kb szemmel tud assemblyt generálni a kódból, annyira közel van."

Figyelembe veve, hogy miket muvel manapsag egy atlag fordito, ebben azert ketelkednek. Persze, ha nem nulla optimalizacioval forditunk.

----------------
Lvl86 Troll - Think Wishfully™

Jaj, ez az oktatas szoveg, azota a Pascal azert megert egynehany implementaciot es meglehetosen jelentos nyelv volt DOS-ra es kesobb - Delphikent - Windowsra. Ennyit az oktatasi celu nyelvekrol. Meg a C, mint oprendszer reszelo nyelv.

(Utobbihoz kulon erdekessegkent hozza lehet venni az ilyen kutatasi projekteket, mint pl. a Singularity es elcsodalkozni, hogy hol tart mar a tudomany, csak mert egyesek hajlandoak voltak vegre 40 eve elhibazott donteseket felulbiralni es nem agyatlan modon hatjogatni, hogy dedede, joez, mert 40 eve lustak voltak forditot irni.)

----------------
Lvl86 Troll - Think Wishfully™

A C fejlesztésénél eredetileg nem számítottak arra, hogy ennyire el fog terjedni. Arra sem számítottak, hogy ilyen hatalmas programokat fognak benne írni. Rövid programoknál pedig kézenfekvő az #include-os megoldás már csak azért is, mert az egyes programrészek fordítása jól elkülöníthetővé válik a teljes programétól. Ez szépen illeszkedik a Unix-os világképbe azzal, hogy az egyes munkafázisokat végző programok egyszerűek maradnak és nem kell a különféle fázisoknak belelátniuk egymás működésébe. Ma már ez nem probléma, mert a C fordítók is lényegesen okosabbak lettek és a számítógépeknek is több tartaléka van. Azonban akkoriban a kevés memóriával rendelkező gépeknél a feladatok izolációja logikus lépés volt.

Egyébként semmi baj nincs az include-dal ha valaki tudja helyesen használni a nyelvet. Sőt, nekem pl. kifejezetten természetesnek tűnik egy ilyen megoldás. Rendszerprogramozáshoz LÉNYEGESEN jobb megoldás mint bármi más, mert sokkal nagyobb betekintést nyújt abba, hogy mi történik a háttérben. Grafikus programokhoz már nem ideális, de igazaból a C-t sem kéne arra használni.

Valamiért elsőre ez ugrott be:

10 GOTO 10
RUN

Pascal mix C. Hülye kérdés de miben irják? Kíváncsi lennék.

------
3 fajta matematikus létezik. Aki tud számolni, és aki nem.

>>> Pascal mix C. Hülye kérdés de miben irják? Kíváncsi lennék.

Elvben C-ben fejlesztik. A nyelv használatához szükséges eszközkészletet a bináris formák mellett akár forrásból is fel lehet telepíteni, de akár telepítés nélkül, weben is ki lehet próbálni.

Kezdéshez viszont érdemes a nyelvről szóló doksikat elolvasni.

Jó ismerkedést!

============================================
"Share what you know. Learn what you don't."

elkezdtem olvasni a faq-t, az alapján elég ígéretesnek hangzik, aki próbálta már, esetleg írhatna róla pár szót.

egzotikus módon lehet értéket adni a változóknak, és egzotikum még benne, hogy több kimenete is lehet egy függvénynek. egyelőre ennyi újdonságot fedeztem fel a bemutató-túrájában

Szerintem szimplán obfuszkált, semmire sem hasonlító, majd mi megmutatjuk milyen a jó nyelv az egész.
- a rövidítés rossz szokás, itt beépítetten van (func)
- az értékadás nemdeterminisztikus abban az értelemben, hogy hol így, hol úgy jelöljük


   var i int = 3
   b := true

- az implicit típus meg aztán végképp nem célszerű (ez nem interpretált nyelv)
- bezzeg, ha const az érték, akkor az implicit típus mellett is egyenlőség kell


   const x = "almafa"

- a for ciklust nem triviális értelmezni (a func-ot ki kell írni, de a for-nál a zárójelpár nem kell)
különösen ha egypár ";" és egyebek elmaradnak.
- if elején extra utasítás? Minek? Előző sorba is elférne

 
if v := math.Pow(x, n); v < lim {

stb.

hogy hol így, hol úgy jelöljük

a var i int = 0 az deklaráció és kezdőértékadás. Ennek rövidebb változata a i := true, szóval ezt végülis úgy jelölöd, ahogy akarod. Ha ugyanez a változó új értéket kap, akkor az = operátort kell használni, tehát ez nem fordul le:


i := 1
i := 2

Elsőre kicsit furcsa lehet ez a működés, de nem olyan vészes, aki meg akar tanulni egy új nyelvet az ennyire legyen már nyitott..

- if elején extra utasítás? Minek? Előző sorba is elférne

Ha az előző sorban lenne akkor a változó hatásköre az egész függvény lenne, így meg csak az if feltétel és a hozzá tartozó blokkok. Én nem tartom hülyeségnek.

"if elején extra utasítás? Minek?"
Scoping. Tippre amit ott definialsz az egyedul az if blokkjaban lesz ervenyes, sehol masutt. Ha az elozo utasitasban definialod, akkor az if parent scope-jaban lesz ervenyes a definiciod, ami esetleg mellekhatassal jarhat.

--

Ki oda vagyik, hol szall a galamb, elszalasztja a kincset itt alant. | Gentoo Portal 

package main

import "fmt"

func main()
{
fmt.Printf("hello, world\n")
}

./hello.go:6: syntax error: unexpected semicolon or newline before {

beszartam :D

Azt nem tudom, hogy Go-ban mi van (gyanítom hogy egy gugli hamar kideríti, de ha te lusta lehetsz, hadd legyek én is), de nem árt, ha nincs rá operátor. Ugyanis az operátor azt a hatást kelti, hogy ez egy egyszerű művelet. A hatványozás nem egyszerű művelet. Nagyon sok függ attól, hogy egészt vagy lebegőpontost akarunk hatványozni, hogy tört vagy negatív-e a kitevő, és eleve, nem minden esetben van jelentése a műveletnek (0^0). Jó az, ha külön függvényt kell rá hívni.
----
Hülye pelikán

A teljesség kedvéért: 0^0 problémája azért érdekesebb annál, mint amit a "nincs jelentése" sejtet.

http://en.wikipedia.org/wiki/Exponentiation#Zero_to_the_zero_power

tl;dr: helyzete válogatja, hogy minek érdemes venni a 0^0 értékét, sok esetben kényelmes 1-nek tekinteni (szemléletes jelentése is van), de bizonyos esetekben ez problémát okoz.

-----------
"Generally, Russian technology assumes dumb machines and smart humans, not the other way around." -- The Russian Tea HOWTO

Ha egy nyelv egységesebb kódolási konvenciókat kényszerít a fejlesztőkre, az szerintem jó dolog. Hogy konkrétan mik ezek a konvenciók az nagyjából tökmindegy, hacsak nem nagyon nagy hülyeség. Ez nem az. (Szerintem pl. jobb az előző sor végére tenni a { -t mert így annyival kevesebb sor megy el boilerplate-re, több kódot lehet nézni egyszerre a képernyőn)

Azonos logikával a } is kerülhetne egy sorral feljebb. Ízlés dolga, bár tény, hogy ennyivel kevesebb dolgot kell lefixálni a kódolási konvenciókban. Másrészről viszont a kódolási konvenciókban általában logika van, emiatt a kényszerítésük szerintem nem jó dolog. Éljen a Perl!!! :-)

Go esetén vannak standard konvenciók a kód formázására. A terjesztésben van pl. egy gofmt nevű tool, ami standard módra formázza a valid forráskódot.

Továbbá más nyelvekkel ellentétben, itt a láthatósághoz (package-private vagy public) nem kell külön kulcsszó, hanem ami nagykezdőbetűs, az public, ami nem, az package-private.

Ajj de szeretem is azt... undoritoan nez ki tole szerintem a kod, es raadasul ertelmetlen is. A zaro kapcsos ne a kezdo kapcsossal legyen egy szinten, hanem a blokkindito utasitassal (if, for, switch, etc), mert engem baromira nem a kapcsos zarojel erdekel, hanem hogy mihez tartozik.
--

Ki oda vagyik, hol szall a galamb, elszalasztja a kincset itt alant. | Gentoo Portal 

Kezdem megérteni, miért szép inkább a Shell script…¹ Meg a PHP-ban az alternatív szintaxis…² – ott nincs ilyen probléma.
¹ Mondjuk ha ott az if a fi-vel van párban, akkor az elif-nek a file-lal kéne… :P
² Template készítésénél mondjuk általában tényleg azt használok…

int getRandomNumber() { return 4; }  // ← aláírás
//szabályos kockadobással választva. garantáltan véletlenszerű.  xkcd

Ez merőben vallási vita, kinek így, kinek úgy tetszik, pont azért eldönthetetlen, mert mindkettő mellett jó érvek szólnak. Az a fontos, hogy egy projekten belül egységes legyen. Az nem tetszik, hogy a nyelv rámkényszeríti, a whitespace kevés kivételtől eltekintve mindig is olyan volt, hogy szabadon lehetett vele bánni. Ez az érvelés, hogy a lexernek előre kell olvasnia... mi? A lexer átugorja a whitespacet, legyen az szóköz, tab vagy újsor, neki aztán rohadtul mindegy, hogy hol van a nyitózárójel, azon a soron vagy a következőben.

Amúgy valaki elmondhatná, hogy mennyiben jobb ez a nyelv, mint tetszőleges komolyabb scriptnyelv (Python, Ruby). Ha azokhoz írt volna a Google egy jó kis fordítót, előrébb lennénk.
----
Hülye pelikán

"Amúgy valaki elmondhatná, hogy mennyiben jobb ez a nyelv, mint tetszőleges komolyabb scriptnyelv (Python, Ruby)."

Pontosan meg lehet határozni benne az adatszerkezeteid memory layoutját. Ez egy szkriptnyelvben általában nem megy.

Bár nem értem miért akarod a Gót a szkriptnyelvekhez hasonlítani, amikor a megjelenésekor mint systems programming language-et mutatták be, noha ma már inkább general-purpose programming language-ként tüntetik fel.

szerintem ez egy g.cijó nyelv, a szintaxison meg felesleges rugózni..

Egyrészt ha nem szintaktusan helyes a program, az nem bug, hanem fordítási hiba, másrészt mivel nincs tökéletesen egyező szintaxis és szemantika két nyelv között, ezért esélyes, hogy tévútra visz, ha a megszokott működést feltételezi az ember. Emellett számomra tényleg könnyen megszokható volt maga a szintaxis; órákban mérhető, nem hetekben.. persze van olyan konstrukció, aminek utána kell nézni időnként, de C-ben is van ilyen.

Aki nem olyan szerkesztot hasznal, ami kepes szintaxisellenorzesre es nem is veszi a faradsagot, hogy leforditsa az elkeszult kodot hogy ellenorizze a szintaxist, csak committol, attol el kell venni a billentyuzetet, meg - biztos ami biztos - az egeret is.
--

Ki oda vagyik, hol szall a galamb, elszalasztja a kincset itt alant. | Gentoo Portal 

Még az is előfordulhat, hogy leváltják androidon a java-t Go-ra?

Érdekes, hogy bár nagy az erőlködés a magas szintű ám rendszerprogramozásra is alkalmas nyelvek területén (röviden: a c/c++ lecserélésére törő szegmens), soknak üzleti/szervezeti támogatása is van pl. Digital Mars D, Google Go, Mozilla Rust ...

Itt valahogy még egyiknek sem sikerült szignifikáns szeletet kiharapni a tortából, pedig a többi területen, pl. a menedzselt nyelveknél C#+Java, szkriptnyelveknél a P betűsek+Ruby+... elég kiegyensúlyozottan osztoznak a piacon, és ott mintha a később jövőknek is nagyobb lehetőségük volt/van magasra törni egy-egy hype hullámon.

Hát nézd, rendszerprogramozásra GC-s nyelvet használni önmagában hatalmas mellé. A pointer aritmetika is szorosan az alacsonyabb szinthez tartozik, ami KELL a rendszerprogramozáshoz. Nem hiszem, hogy a Go-t erre szánták volna, bár a gugliból sok mindent kinézek.
----
Hülye pelikán

Igazából szvsz. egy jó részére megoldást nyújtana a C#, mert a Java-val ellentétben valamivel egyszerűbb menni lefele, persze, még így is elég magas szintű nyelv. Na meg igen erősen akadályozza, hogy mindenki az MS-hez köti és fél tőle, pedig nagyon jó nyelv.

Annyiban viszont hátrányban van, hogy gyakorlatilag kell mögé a framework is.

Igény mindenesetre lenne rá, hogy legyen valami köztes megoldás, ami megpróbálja egyesíteni a natív kód előnyét a menedzselt környezetek dolgok rugalmasságával és gyors fejlesztési lehetőségeivel.

----------------
Lvl86 Troll - Think Wishfully™

Eredetileg systems programming language-ként hirdették.

Magas szintű programozás nem megy garbage collector és managed memory nélkül.

Ugyanakkor vegyük figyelembe a Go két fontos feature-ét:
- Lehetővé teszi, hogy pontosan megszabjuk az adatszerkezeteink memory layoutját. (Java ilyet nem tud, C#-ban már többé-kevésbé lehetséges.)
- Van "unsafe" mód, ahol lehet malloc/free-t hívni és pointeraritmetikázni. Ezeket nem gyűjti a garbage collector.
- A garbage collector runtime kikapcsolható.

Hát amikor azzal kell baszakodni, hogy mikor foglalok le memóriát és mikor lehet, illetve mikor kell felszabadítani, az nem high-level programming.

Amikor az emberek C++-ban szeretnének magas szinten programozni, akkor jellemzően orrba-szájba használnak smart pointereket, de ...

a) azok csak a takarítás terhét veszik le (részben) az ember válláról, tehát csak a GC feladatát látják el (részben). A managed memory ennél több, a GC mellett a védelem is része, amely egyrészt meggátolja, hogy hülyeséget csinálj, továbbá több segítséget ad a hiba azonosításához és javításához.
Például C++-ban bármilyen hiba jelentkezhet SIGSEGV formájában, míg Pythonban segmentation violation egyszerűen nem lehetséges. Persze van Pythonban is run-time error, de ott elsőre valami értelmesebb hibaüzenetet kapsz.

b) nehézkes a használatuk. Van vagy féltucat féle smart pointer (auto_ptr / unique_ptr, scoped_ptr, shared_ptr, weak_ptr, ...) aminek a használatát meggondolhatod. Jó, persze ezek nagyrésze pusztán teljesítmény-optimalizáció, és ha magas szinten akarsz programozni, akkor egyszerűen mindig shared_ptr-t használsz, de ez sem jó: a hivatkozási körök ellen nem véd, így ha nem akarsz memory leakes programot kiadni, akkor át kell gondolnod, hogy lehet-e kör a hivatkozásokban, tehát a probléma megoldásán túl továbbra is muszáj a memóriakezelésen baszakodni.

Azért az jól látszik, hogy egyrészt fogalmad sincs arról, amiről beszélsz, másrészt nem tanítottak meg programozni.
A magas szint nem a menedzselt kódnál kezdődik.
Szigorúan véve minden programozás magasszintű, ami nem assembly.
Kicsit kevésbé szigorúan nézve a magasszintűség nem egy bites attribútum, minél messzebb van a géptől annál magasabb. Ilyen szemszögből nézve a C egy viszonylag alacsonszintű nyelv, a Python meg nagyon magas.

Amúgy hallottál már a RAII-ról? Azt mondják ne csak a sima pointereket, mindenféle pointert kerüljünk. A kód nagy része megírható anélkül, hogy akár csak egy pointert (akár sima, akár smart) látnál. És mégsincs sem menedzselt memória (ami tökönlövi a hatékonyságot), sem GC.
----
Hülye pelikán

"Szigorúan véve minden programozás magasszintű, ami nem assembly."

Régen valóban így tekintettek a helyzetre, de azóta egyre inkább eltolódik ez. Igazából nincs egyértelmű meghatározása annak, hogy hol a határ a low-level és a high-level között.

"Kicsit kevésbé szigorúan nézve a magasszintűség nem egy bites attribútum."

Ez pontosan így van. De amelyik nyelvből hiányzik a memória absztrakciója, az nem tartozhat a legfelsőbb rétegbe.

Megnézném azt a C++ kódot, amiben egyáltalán nincsenek pointerek. RAII előhozása eléggé Red Herring szagú, mert RAII
a) általánosan mindenféle erőforrás felszabadításáról szól, míg a GC csak a memóriával foglalkozik;
b) csak akkor segít, ha az egyes erőforrásokat fordított sorrendben kell felszabadítani, mint ahogyan lefoglaltuk.

"ami tökönlövi a hatékonyságot"

A programozásban mindenféle absztrakció célja a developer productivity növelése. Ugyanakkor ezek az absztrakciók gyakran a run-time performance rovására mennek. Ha ez veszélyezteti a projekt teljesítménybeli követelményeinek teljesülését, akkor igenis le kell menni alacsony szintre. Ellenkező esetben az alacsony szinten történő fejlesztés többletköltsége kidobott pénz.

RAII. Egyrészt egy resource objektumot lehet adogatni körbe (és visszafele), tehát nem feltétlenül fordított sorrendben halnak el, másrészt ha csak memóriára használod, akkor csak memória felszabadításról (és kezelésről) fog szólni. Elvégre most a pointereknél jött elő, pointer pedig memóriába mutat.

És ott a kompromisszum. Igen, megfelelően alacsonyra kell menni, hogy a performansz limiteket be lehessen tartani. Szerintem nincs vita köztünk, csak te nem hiszed el, hogy a C++ magasabb szintű, mint azt gondolod. Attól, mert nincs benne beépített memória absztrakció, még nem lesz egy alacsonyszintű nyelv, sőt.
----
Hülye pelikán

Az az ő dolguk, hogy mit csomagolnak (végső soron MINDENHOL pointerekig lehet lemenni). A C++ egy erősen réteges nyelv, legalábbis ha jól használják.

A blub paradoxon nem fenyeget, hidd el. Egyik kedvenc nyelvem egy elég magasszintű nyelv, nevezetesen a Python, minden nyalánkságával együtt.
----
Hülye pelikán

Amúgy hallottál már a RAII-ról? Azt mondják ne csak a sima pointereket, mindenféle pointert kerüljünk. A kód nagy része megírható anélkül, hogy akár csak egy pointert (akár sima, akár smart) látnál. És mégsincs sem menedzselt memória (ami tökönlövi a hatékonyságot), sem GC.

RAII. Egyrészt egy resource objektumot lehet adogatni körbe (és visszafele), tehát nem feltétlenül fordított sorrendben halnak el, másrészt ha csak memóriára használod, akkor csak memória felszabadításról (és kezelésről) fog szólni. Elvégre most a pointereknél jött elő, pointer pedig memóriába mutat.

csak nem veszed észre, hogy továbbra is smart pointerről beszélsz..

"Igen, megfelelően alacsonyra kell menni, hogy a performansz limiteket be lehessen tartani."

Milyen "performansz" limiteket? Nem fog érdekelni senkit az, hogyha mondjuk X művelet végrehajtásakor 0.01 sec helyett 0.05 sec-et matat a gép egy gomb megnyomásakor, pl. egy ügyviteli rendszer esetén. Ha ezt a műveletet naponta 10M nagyságrendben végzi egy program, automatizálva, ott már számít.

Szóval azért lehetőleg ne ilyen bullshit generator szintű indokokkal próbáljuk már alátámasztani azt, ami egyébként sem igaz.

----------------
Lvl86 Troll - Think Wishfully™

Az ADA GC-je annyi, hogy amikor kimegy scope-ból a pointer, akkor minden olyan típusú ojjektumot felszabadít. Azért ezt GC-nek nevezni erős.
Az ADA pedig nem rendszerprogramozásra lett tervezve, sőt, kifejezetten alkalmazásfejlesztés volt a cél. Nem is nagyon alkalmas rá, mert rendszerprogramozni alacsonyszintű hekkelések nélkül nem nagyon lehet.
----
Hülye pelikán

Beágyazott rendszerekre. Olyat mondjuk nem írtam még, de nem hinném, hogy arra alkalmazást fejlesztenének, és nem rendszert.

Szerk:
"Az ADA GC-je annyi, hogy amikor kimegy scope-ból a pointer, akkor minden olyan típusú ojjektumot felszabadít. Azért ezt GC-nek nevezni erős."

Ez sem mindig igaz, mert ha a típusa nem kerül ki, a pointer sem (pl. láncolt lista elemeinek a típusa). Így "kézzel" kell felszabadítani, explicit módon.