Praeteritis mensibus usus sum Ite ad effectum deducendi. (proxime.: codicem probare functionalitatem ideae) in libero tempore, partim in ipsa lingua programmandi studere. Progressiones ipsae valde simplices sunt et propositum huius articuli non sunt, sed experientia usus Go ipsa pauca de eo meretur. Ite promissa esse (proxime.: articulus in 2015 scriptum) vulgaris lingua pro gravi scalable codice. Lingua a Google creata est, ubi active usus est. Solum linea, I honeste puto consilium Go lingua malum esse programmatoribus captiosis.
Programmers infirma disposito?
Perge perfacile est ad discendum, tam facilis est introductio vesperi me una, post quam potui iam codicem operose. Liber discere solebam Ite vocatur (), online praesto est. Liber, sicut ipsum codicem Go fons, facile lectu est, exempla bona habet, et circiter 150 paginas uno sedente legi potest. Haec simplicitas primum recreat, praesertim in programmando mundo technologia nimis implicata. In fine autem citius vel serius oritur cogitatio: "Itane est?"
Google simplicitas Ite vindicat suum punctum venditionis et lingua ad maximam productivam in magnis iugis destinata est, sed dubito. Notae sunt quae vel desunt vel nimis explicatae sunt. Et omnes propter diffidentiam tincidunt, posito quod aliquid juris facere non possunt. Haec simplicitatis cupiditas erat conscia definitorum consiliorum linguarum, et ut plene intelligatur quid opus sit, intellegendum est motivum tincidunt et quid in Go assequi conentur.
Cur igitur simplex? Hic es duobus quotes (proxime.unus e co-creatoribus linguae Go) ;
Praecipuum hic punctum est programmatores nostri (proxime.: ) non sunt inquisitores. Hi fere adolescentuli ad nos pervenerunt, forte studuerunt Javam, vel C/C++, vel Python. Linguam magnam capere non possunt, sed simul volumus eos ut bonum programmatum crearent. Quam ob rem lingua eorum facilis est ad intellegendum et discendum.
Nota sit, fere similis C. Programmatores laborantes apud Google primos gestas suas incipiunt et maxime familiares sunt linguis processualibus, speciatim familiae C. Necessitas celeris fructibus in nova programmandi sermone significat ne lingua nimis radicitus esse debeat.
Quid est? Itaque Rob Pike radicaliter dixit tincidunt apud Google non esse bonum, ideo linguam pro fatuis creaverunt (proxime.obstupefactus) ut aliquid facere possint. Qualem arrogantem vide in collegas tuos? Credidi semper tincidunt Google e clarissimis et optimis in Tellure teneri. Num aliquid difficilius tractare possunt?
Artificia nimiae simplicitatis
Simplex est, in omni consilio dignus est finis, et difficile conatur facere aliquid simplex. Cum tamen problemas implicatas solvere (vel etiam exprimere) conatur, multiplex instrumentum interdum necessarium est. Complexitas et intricatio non optimae linguae programmationis notae sunt, sed medius locus est in quo lingua elegantes abstractiones creare potest, quae facile ad cognoscendum et utendum sunt.
Non valde expressa
Propter simplicitatem suam, Ite caret constructis quae in aliis linguis sentiuntur ut naturales. Hoc primo videri potest utilem, sed in usu verboso codice provenit. Causa huius rei perspicua esse debet - oportet ut facile tincidunt ad aliorum codicem legatur, re vera hae simplices modo facilitati noceant. Go are no abbreviations in : vel multum vel nihil.
Exempli gratia, utilitas solaris qui legit stdin vel lima ex mandato linea argumentorum hoc spectare videtur;
package main
import (
"bufio"
"flag"
"fmt"
"log"
"os"
)
func main() {
flag.Parse()
flags := flag.Args()
var text string
var scanner *bufio.Scanner
var err error
if len(flags) > 0 {
file, err := os.Open(flags[0])
if err != nil {
log.Fatal(err)
}
scanner = bufio.NewScanner(file)
} else {
scanner = bufio.NewScanner(os.Stdin)
}
for scanner.Scan() {
text += scanner.Text()
}
err = scanner.Err()
if err != nil {
log.Fatal(err)
}
fmt.Println(text)
}Etsi hoc signum etiam quam maxime generalem esse nititur, verbositas obsistit Go coactus, et consequenter solvendo problema simplicem in magna codicis quantitate.
Hic, exempli gratia, eiusdem quaestionis solutio est :
import std.stdio, std.array, std.conv;
void main(string[] args)
{
try
{
auto source = args.length > 1 ? File(args[1], "r") : stdin;
auto text = source.byLine.join.to!(string);
writeln(text);
}
catch (Exception ex)
{
writeln(ex.msg);
}
}Et quis nunc lectior? D. His codicem multo magis lecturus censeo quod actiones clarius describit. D utitur conceptibus complexis multo (proxime.: и ) quam in Go exemplo, sed revera nihil implicatum est ad intelligendum ea.
Infernum exscribend
Popularis suggestio pro melius Go est generalitas. Hoc saltem adiuvabit ne superflua exemplaria exemplaria ad omnes notitias typos sustineat. Exempli gratia, functio ad summam indicem numerorum sumendam non aliter perfici potest quam per transennam suam fundamentalem functionem pro quolibet integer genere: non est alius modus;
package main
import "fmt"
func int64Sum(list []int64) (uint64) {
var result int64 = 0
for x := 0; x < len(list); x++ {
result += list[x]
}
return uint64(result)
}
func int32Sum(list []int32) (uint64) {
var result int32 = 0
for x := 0; x < len(list); x++ {
result += list[x]
}
return uint64(result)
}
func int16Sum(list []int16) (uint64) {
var result int16 = 0
for x := 0; x < len(list); x++ {
result += list[x]
}
return uint64(result)
}
func int8Sum(list []int8) (uint64) {
var result int8 = 0
for x := 0; x < len(list); x++ {
result += list[x]
}
return uint64(result)
}
func main() {
list8 := []int8 {1, 2, 3, 4, 5}
list16 := []int16{1, 2, 3, 4, 5}
list32 := []int32{1, 2, 3, 4, 5}
list64 := []int64{1, 2, 3, 4, 5}
fmt.Println(int8Sum(list8))
fmt.Println(int16Sum(list16))
fmt.Println(int32Sum(list32))
fmt.Println(int64Sum(list64))
}Quod exemplum ne impressis quidem generibus opus est. Aditus hic principium perfecte violat non te iterandi (.) unum ex clarissimis et manifestis principiis, ignorans unde sit multorum errorum. Qiiid Ite hoc facit? Haec est horrida facies linguae.
Idem exemplum in D:
import std.stdio;
import std.algorithm;
void main(string[] args)
{
[1, 2, 3, 4, 5].reduce!((a, b) => a + b).writeln;
}Simplex, elegans et recta ad rem. Munus hic usus est reduce ad template genus et praedicatum. Ita, haec iterum magis quam Go version perplexa est, sed non difficile est programmatibus callidis ad intellegendum. Quod exemplum facilius est ponere et legere facilius?
Simple genus ratio bypass
Opinor Ite programmatores legentes hoc spumare ad os et eiulare: "Male facis!" Bene, est alius modus facere munus ac genera generale, sed omnino ratio generis dissolvit!
Vide hoc exemplum linguae stultae figere ad operandum circa problema:
package main
import "fmt"
import "reflect"
func Reduce(in interface{}, memo interface{}, fn func(interface{}, interface{}) interface{}) interface{} {
val := reflect.ValueOf(in)
for i := 0; i < val.Len(); i++ {
memo = fn(val.Index(i).Interface(), memo)
}
return memo
}
func main() {
list := []int{1, 2, 3, 4, 5}
result := Reduce(list, 0, func(val interface{}, memo interface{}) interface{} {
return memo.(int) + val.(int)
})
fmt.Println(result)
}Hoc implementation Reduce sumptum a articulum (proxime.: translationem invenire non potui, gaudebo si hoc adiuvas). Bene, si idiomaticum est, odiosum exemplum non idiomaticum videre. Consuetudinem interface{} - mimum, et in lingua typing praeterire tantum opus est. Haec interpositio vacua est et omnes rationes efficiunt, plenariam libertatem omnibus permittens. Hoc genus programmandi valde deformis est, et non omnes. Acrobatica facinora huiusmodi huiusmodi meditationis usum runtimorum requirunt. Etiam Rob Pike non placet hominibus, qui hoc abutuntur, sicut in quadam enunciationibus commemoravit.
Validum est hoc instrumentum quo caute utendum est. Vitanda est nisi stricte necessaria.
D exempla pro hac ineptia accipere vellem. Quomodo potest quis dicere interface{} aut etiam typus tutus magis readable?
Vae Dependency Management
Ite has a built-in dependentity system built on top of popular hosting providers . Instrumenta quae cum Ire veniunt cognoscunt circa haec officia et possunt extrahere, aedificare, et ex eis in uno lapsu codicem instituere. Dum hoc magnum est, maioris vitii est cum versione! Ita, verum est quod ex officiis quasi github vel bitbucket utens utens Instrumenta ex fonte codicem obtinere posse, sed versionem exprimere non potes. Et iterum simplicitas in sumptu utilitatis. Talem sententiam logicam intelligere non possum.
Post interrogationes de solutione huius quaestionis, turma evolutionis Ite creata est qui quomodo circa hanc rem essent habituri. Commendatio eorum erat ut repositorium totum in tuo consilio uno die exscriberet ac illud relinqueret ut est. Quid infernum cogitant? Mirabiles habemus versiones systemata temperantiae magna cum tagging et versionis auxilio quod Go creatores ignorare ac fontem codicem tantum effingo.
Impedimenta culturalia ab XI
Opinor, Ire elaboratum est ab iis qui omni vita usi C et ab iis qui aliquid novi experiri nolebant. Lingua describi potest C cum extra rotis (orig.: ). Ideae novae in eo nullae sunt, nisi subsidium parallelismi (quod obiter mirum est) et hoc turpe est. Praeclaram habes parallelismum in lingua vix utili, claudo.
Alia quaestio crepuit quod Go est lingua processualis (sicut horror tacitus C). Finem scribendi codicem in stilo processuali qui pervetustis et outdated sentit. Scio rem programmandi ordinatam non esse glandem argenteam, sed magnum fore ut singula in genera abstrahere et encapsulationi praebere possit.
Simplicitas ad utilitatem vestram
Ite designatus est simplex et succedit in illo meta. Scriptum est programmatibus infirmis utens vetus lingua ut exemplum. Perfectum fit simplicibus instrumentis ad res simplices faciendas. Legere praesent facilis et usu.
Est valde verbosum, unimpressivum, et malum programmatibus captis.
Спасибо pro emendationibus
Source: www.habr.com