Quando si preme il soffitto di vetro di Coding produttività. . .

Come erba programmatore , ho potuto trascorrere una programmazione ora e in quel momento ho imparato così tanto l'ora successiva era come tre serie di combinata prima.

La produttività è cresciuta in modo esponenziale senza alcun segno di fermarsi. Quando la crescita è rallentata, avrei scoperto una nuova serie di strumenti, un nuovo quadro o anche un linguaggio del tutto nuovo e la mia produttività avrebbe preso un coglione, un balbettare, saltare e fare un salto in avanti enorme.

Con un po 'di smoothing saresti ancora un grosso curva esponenziale .

Come Ralph W. Sockman, chiunque egli sia, una volta disse: "La più grande isola della conoscenza, lungo il litorale di meraviglia."

L'esperienza approfondisce una specialità

Quando la mia conoscenza non è molto vasta, la meraviglia aumentando il solo scopo che ci fossero più cose che ho potuto esplorare. spinge in una sola direzione ha mostrato un sacco di roba nuova e fresca che ho potuto esplorare per diventare ancora migliore. La vita era grande. E semplice!

Ma ultimamente questa si è fermato accadendo. Ho ottenere rendimenti quasi esattamente lineari sul tempo che investire, a volte anche sublineare. Sembra che non importa quale nuovo strumento posso aggiungere al mio arsenale, la produttività non è interessato molto. Imparare il nuovo strumento rende a malapena per il tempo investito in apprendimento, piuttosto che fare da zero.

Un soffitto

Hacking porta al bordo della conoscenza

Per esempio, ho appena finito un progetto molto semplice per un amico:

• importare alcuni dati di pianificazione da Excel a postgres
• interfaccia web per visualizzare la scheda di classe
• interfaccia web per modificare le pianificazioni

Semplice diritto?

Con molti anni di scrittura di script python, un sacco di esperienza in dati munging e innumerevoli interfacce web sotto la cintura, questo progetto dovrebbe essere una passeggiata nel parco.Considerando Potrei farlo nel sonno, sicuramente non dovrebbe essere più che vale la pena di un pomeriggio di lavoro.

Ci sono volute 20 ore .

È molto difficile spingere al limite

E no, non è perché ho ​​passato tanto tempo il controllo Twitter , Reddit , HackerNews , Facebook ed e-mail. Ho ottimizzato questi problemi fuori dal mio tempo di lavoro quando ho iniziato ad usare la tecnica del pomodoro  circa un anno fa. Un enorme  vantaggio per la produttività.

Certo, sono stato costretto a usare un framework web che non ho mai usato prima - Bottiglia. Mi sa che ha aggiunto due ore per i tempi di sviluppo, è davvero molto molto semplice. Imparare bottiglia era al livello di imparare una nuova sintassi per Django.

Si rilascia un thingy opensource

Facile.

Il codice HTML / CSS di solito prende un po 'per progetti di questo tipo, ma ho usato Bootstrap.Completamente magazzino. Quasi nessuna modifica. Questo non era un problema neanche.

E tuttavia, un progetto che richiede quasi nessuna pensiero, in cui non stavo facendo alcun Rasatura Yak e il bilancio era decisamente troppo stretto per scrivere il codice HTML in haiku ... ancora preso 20 ore. Questo è davvero troppo.

Ma nella scala delle cose ...

Molte domande

Non ho una risposta, ma io ho una domanda: Che cosa è un ragazzo di fare quando / se il soffitto di vetro è raggiunto? Assicurati di scegliere progetti più severe? Per saperne di strumenti sempre più, ma con rendimenti decrescenti? Concedere che alcune cose solo questione di tempo e rinunciare?

Se io sono un programmatore 1x, come faccio a diventare un programmatore 5x? Almeno una 2x uno?Se mi capita di essere un programmatore 10x, come faccio a diventare un programmatore 100x? Come posso anche scoprire quanto programmatore X sono io?

Corso Java - Corsi Java - Corsi programmazione Java

 Corso programmazione Android - Certificazione Android

Interviste agli sviluppatori - Approccio primo codice

Una delle sfide che ho visto persone che incontrano durante l'esecuzione dei progetti è che spesso finiscono con l'avere le persone nella loro squadra (molte volte vagliati da alcuni esperti) che non sono bravo a scrivere codice di qualità. Ci potrebbero essere molti argomenti che il codice scritto non è l'unica cosa che quando si lavora in un'organizzazione IT, ma ho osservato da vicino e costruito la mia teoria.

La maggior parte dei progetti che si eseguono o applicazioni che si costruisce non ci richiede di scrivere codice da zero. Il che significa, o qualcuno ha già scritto un po 'di codice (si intende anche il progetto esiste già) e stiamo estendendo le specifiche di progettazione, oppure semplicemente mantenendo solo quanto è necessario per mantenere i nostri utenti finali felice. Sviluppo del software, non è creato!

Sono sicuro che alcuni dei lettori avrebbe lavorato sul verde campo progetti e che non sarebbero d'accordo a quanto sopra detto. Io stesso, hanno lavorato su diversi progetti di green field, ma questi progetti sono molto rare da trovare. Il più delle volte, i progetti che sono sul punto di andare in pensione tendono a produrre green field progetti o progetti che si rivolgono a una serie distinta di requisiti che devono essere utilizzati per uno scopo specifico risultano essere green field progetti. Ma questo numero è piccolo. O metterlo in altre parole, il risultato ottenuto da questi progetti è inferiore.

Credetemi, le competenze necessarie per la progettazione di un verde campo di progetto sono gli stessi tenuti a mantenere una versione di un progetto "live". Ecco dove la cattura è. Progetti di manutenzione non sono più facili da sviluppare. La scrittura di codice all'interno dei confini del design creato da qualcuno è più complesso di definire i confini e la scrittura di codice al loro interno. Oh, certo che se non si desidera che il codice sia mantenibile, leggibile, scalabile e quindi non dobbiamo preoccupare di qualità del codice in un progetto di manutenzione.

Sviluppo del software, non è creato! E questa evoluzione richiede agli sviluppatori di essere in grado di scrivere codice, mentre svolgono altre attività di monitoraggio, rendicontazione e gratificante. E anche se voi oi vostri membri del team sono impegnati in qualsiasi attività non-sviluppo, essendo in grado di scrivere codice è il modo più semplice per affinare le tue abilità analitiche .

Quindi, con questa filosofia, preferisco i candidati che non necessariamente eseguire l'operazione di sviluppo su base regolare, ma in grado di scrivere codice, se la necessità di essere. Ora, non c'è bisogno di essere padroni del codice. Hai bisogno di essere logici-cracker e il "can-do" atteggiamento- man.

Quando intervistare un candidato di solito verificare le sue capacità di comunicazione e attitudine, tecnica e capacità d'analisi, se gli viene richiesto di scrivere codice, presentazione, leadership e capacità di assunzione di rischi per i ruoli senior e .... (Può essere un HR può aggiungere più qualità schermati).Ma tutti i ruoli è necessario che il candidato nella sana logica. Quindi, per la prova logica, preferisco dare un programma molto semplice per scrivere in qualsiasi lingua di loro scelta. L'inglese è anche una delle lingue!  Credetemi vedo respingimenti 40% in questa fase di colloquio. I candidati con competenze di nicchia a volte non sono in grado di pensare attraverso la soluzione. Forse è lo stress, o può essere, è che non si aspettavano una domanda così semplice. Per chiedere a qualcuno di scrivere il codice, non si sta verificando il loro sviluppo-quoziente. Invece si verifica se sono in grado di applicare la logica in problemi di scala minore o maggiore .

Come dire, una questione dei miei preferiti è,

Con semplici equazioni matematiche, scrivere un programma che cambierà due numeri

Ci sono diverse soluzioni a questo problema. Ma quando qualcuno utilizza più di 2 variabili, ti lasciano altra scelta che di respingere. Con 3 variabili, anche un 10-grade studente sarebbe in grado di scambiare 2 numeri. Che questa affermazione si riferisce al problema sta applicando la matematica che abbiamo imparato molto tempo fa.

Un altro semplice programma che io in genere chiesto loro di scrivere è,

Mentre si scorre 1 a 100, per ogni numero dispari di stampa "Pollici" e anche per stampare i numeri di "Up". Per un numero primo, stampare "ThumbsUp"

Un altro,

Se per ogni 3 passi che prendo avanti, prendo uno passo indietro. Quando ho incrociato un punto che si trova a 100 passi avanti a me?

E 'ancora una volta la matematica - nessuna conoscenza linguaggio di programmazione. E se si sta parlando di un candidato che conosce un linguaggio di programmazione, è meglio chiedere loro di scrivere un semplice programma di dire fattoriale, o la serie di Fibonacci. Non stiamo guardando risposte perfette qui. Stiamo esaminando il modo in cui analizzare un problema, il loro approccio, la loro disponibilità a fare qualcosa che non hanno fatto da tempo.

Quando discussione sulla progettazione del software ci sono ampi di domande disponibili su Internet e quasi tutti i candidati sarebbe andato attraverso di loro. Ma un problema in tempo reale può essere un googly alle menti più brillanti. Anche io ho affrontato un googly in una discussione che ho avuto qualche tempo fa. Ancora una volta, uno dei miei preferiti è puzzle di progettazione,

Abbiamo l'obbligo di costruire un tic-tac-toe gioco per 2 giocatori, X e O , che si alternano segnando gli spazi in una griglia 3 × 3. Il giocatore X di solito va per primo. Il giocatore che riesce a mettere tre punti rispettive in una riga orizzontale, verticale o diagonale vince la partita.

Se si dovesse progettare questo gioco (non si sviluppano), identificare le classi che si potrebbero creare?

La maggior parte dei candidati, qui, interpretano male la domanda. Iniziano a descrivere le interfacce ed ereditarietà avrebbero usato, o potrebbe iniziare con un'applicazione Windows e definire gli elementi dell'interfaccia utente come griglia, pulsanti, ecc Tutto è dato come risposta, ma i nomi delle classi.

Problema dichiarazioni potrebbero essere molte. Puzzle potrebbe essere infinita. Quando si stanno assumendo qualcuno, avere l'uomo che si poteva sedere oltre a te e sfida la logica e quoziente. Non uno che mantiene apprezzare la tua intelligenza!

Corso Java - Corsi Java - Corsi programmazione Java

 Corso programmazione Android - Certificazione Android

Algoritmo della settimana: Trovare il più basso antenato comune

Introduzione

Ecco un compito relativo alla struttura di dati ad albero. Dati due nodi, si può trovare il loro minimo comune antenato?

È un dato di fatto, questo compito ha sempre una soluzione adeguata perché almeno il nodo radice è sempre un antenato comune di tutte le coppie di nodi. Tuttavia, qui il compito è di trovare il più basso, che può essere abbastanza lontano dalla radice.

A noi non importa che tipo di alberi che abbiamo. Tuttavia la soluzione, come vedremo, può essere molto diverso a seconda del tipo di albero. In effetti trovare il minimo comune antenato può avere complessità lineare per gli alberi binari di ricerca, che non è vero per gli alberi normali.

Panoramica

Diciamo che abbiamo un albero (non binario!) E due nodi di questo albero. Il compito è quello di trovare il loro minimo comune antenato. Il fatto è che non ne so molto di cui sembrano essere nella struttura.

Possiamo pensare a questo albero come un albero DOM di una linea singola pagina HTML. Non è binario o bilanciata e non può essere sicuro dove questi nodi sono.

Prima dobbiamo trovare entrambi i percorsi dalla radice a ciascuno dei nodi di destinazione. Si noti che questo richiede memoria aggiuntiva! Poi, nel tempo lineare, siamo in grado di passare attraverso questi "percorsi" ed eseguirà la scansione dalla radice verso il basso per i nodi. Ci aspettiamo che questi array di essere uguali almeno nel loro primo elemento (la radice). L'utilizzo di questo scenario il più basso antenato comune è l'ultimo elemento uguale in entrambi gli array.

Una volta che sappiamo i percorsi dalla radice verso il basso per i nodi, possiamo confrontare, al fine di trovare il minimo comune antenato!

Per vedere come questo algoritmo può essere cambiato radicalmente a seconda della struttura dei dati, vediamo un altro esempio. Ora diciamo che abbiamo un albero binario di ricerca (BST). Sappiamo che in un BST tutti gli elementi della sub-tree sinistra sono più piccole della radice e tutti gli elementi sulla destra sub-tree sono maggiori della radice. Questo è vero anche per la sinistra e la destra sotto-alberi.

Ora, perché stiamo cercando il più basso antenato comune, non abbiamo bisogno di raccogliere i percorsi dalla radice ai nodi in due matrici. Sappiamo solo che gli elementi superiori siano a destra, mentre gli oggetti più piccoli sono a sinistra. Questo può aiutarci a trovare la tariffa più antenato partendo direttamente dalla radice.

In un BST confrontiamo entrambi i valori con un dato nodo (a partire dalla radice). Nel caso in cui il valore del nodo è in mezzo a loro - questo è il minimo antenato comune. In caso contrario - andiamo sia a sinistra oa destra!

Quello che facciamo è quello di confrontare le due chiavi dei nodi di destinazione con il tasto principale.Se uno dei tasti sono più piccoli, e l'altro è maggiore di chiave della radice, allora ovviamente la radice è il più basso antenato comune. Questo è vero perché uno degli elementi sarà in qualche parte sinistra sub-tree, mentre l'altro sarà nella giusta sub-tree.

Nel caso in cui entrambi i valori sono maggiori (o minori) che la radice, siamo in grado di spostarsi a destra (oa sinistra) sub-tree e riprovare con la stessa procedura. Così il primo nodo che chiave è tra i due valori di destinazione sarà il più basso antenato comune.

Codice

Ecco una applicazione molto semplice PHP che ci mostra questi due algoritmi.

01.classe Albero

02.{

03.pubblico $ nodo = null;

04.pubblico $ id = null;

05.pubblico $ genitore = null;

06.pubblico $ bambini = matrice ();

07. 

08.pubblica funzione __construct ( $ node , $ id = null)

09.{

10.$ this -> nodo = $ nodo ;

11.$ this -> id = $ id ;

12.}

13. 

14.pubblica funzione addChild (Node e $ n )

15.{

16.$ n - genitore> = $ this ;

17.$ this -> figli [] = $ n ;

18.}

19. 

20./ **

21.* Restituisce un elemento dal suo ID

22.*

23.* @ param $ id mescolati

24.* @ return nodo

25.* /

26.pubblica funzione di ricerca ( $ id )

27.{

28.se ( $ this -> id == $ id ) {

29.ritorno $ this ;

30.}

31. 

32.$ a = false;

33. 

34./ / ricerca in tutti i bambini a partire dai più a sinistra

35.foreach ( $ this -> bambini da $ bambino ) {

36.$ a = $ bambino -> Ricerca ( $ id );

37.}

38. 

39.ritorno $ a ;

40.}

41. 

42./ **

43.* Trova un percorso dalla radice alla

44.* voce e la restituisce come una lista

45.*

46.​​* @ param $ id mescolati

47.* @ return array di

48.* /

49.pubblica funzione find_path ( $ id , & $ path )

50.{

51.array_push ( $ path , $ this -> id);

52. 

53.se ( $ this -> id == $ id ) {

54.ritorno 1;

55.}

56. 

57.foreach ( $ this -> bambini da $ bambino ) {

58.se (1 == $ bambino -> find_path ( $ id , $ path )) di ritorno 1;

59.array_pop ( $ path );

60.}

61.}

62. 

63.pubblica funzione __toString ()

64.{

65.ritorno $ this - nodo>. ' ' . $ this -> id. "\ n" ;

66.}

67.}

68. 

69.$ dom = nuovo Albero ( 'DOM' , 'root' );

70. 

71.$ corpo = nuovo Albero ( 'BODY' , 1);

72.$ div1 = nuovo Albero ( 'DIV' , 'div-1' );

73.$ div2 = nuovo Albero ( 'DIV' , 'my-id' );

74. 

75.$ a = nuovo albero ( "A" , 'un po' di-link ' );

76. 

77.$ dom - addChild> ( $ body );

78.$ corpo - addChild> ( $ div1 );

79.$ corpo - addChild> ( $ div2 );

80.$ div2 - addChild> ( $ a );

81. 

82.$ path1 = $ path2 = matrice ();

83.$ dom -> find_path ( 'div-1' , $ path1 );

84.$ dom -> find_path ( 'un po-link' , $ path2 );

Trovare più basso antenato comune in un BST

01.classe Albero

02.{

03.pubblica $ chiave ;

04. 

05.pubblico $ genitore   = null;

. 06pubblica $ sinistra     = null;

07.pubblico $ destra    = null;

08. 

09.pubblica funzione __construct ( $ key )

10.{

11.$ this -> key = $ chiave ;

12.}

13. 

14.pubblica funzione insert (Albero $ n )

15.{

16.se ( $ this -> tasto < $ n - tasto>) {

17.se ( $ this -> destro == null) {

18./ / inserire

19.$ this -> diritto = $ n ;

. 20$ n - genitore> = $ this ;

21.} else {

22.$ this -> tasto destro> insert ( $ n );

23.}

24.}

25.se ( $ this -> tasto> $ n - tasto>) {

26.se ( $ this -> sinistro == null) {

27./ / inserire

28.$ this -> sinistra = $ n ;

29.$ n - genitore> = $ this ;

30.} else {

31.$ this -> sinistra-> insert ( $ n );

32.}

33.}

34.}

35.}

36. 

37.$ t = nuovo albero (10);

38. 

39.$ n1 = nuovo albero (20);

. 40$ n2 = nuovo albero (5);

41.$ n3 = nuovo albero (7);

42.$ n4 = nuovo albero (13);

43. 

44.$ t - inserto> ( $ n1 );

. 45$ t - inserto> ( $ n2 );

46.​​$ t -> insert ( $ n3 );

47. 

48.funzione find_common ( $ node1 , node2 $ , $ albero )

49.{

50.se ( $ node1 -> tasto < $ albero -> && chiave $ node2 -> tasto> $ albero- tasto>) {

51.ritorno $ albero ;

52.} else se ( $ node1 -> tasto < $ albero -> && chiave $ node2 -> tasto <$ albero - tasto>) {

53.find_common ( $ node1 , node2 $ , $ albero - a sinistra>);

54.} else se ( $ node1 -> tasto> $ albero -> && chiave $ node2 -> tasto> $ albero - tasto>) {

55.find_common ( $ node1 , node2 $ , $ albero -> destra);

56.}

57.}

58. 

59.$ nodo = find_common ( $ n3 , n4 $ , $ t );

Applicazione

Un tipico caso d'uso di questo algoritmo è trovare il minimo comune antenato di due nodi in un albero DOM. A volte abbiamo solo bisogno di collegare un listener di eventi per entrambe le voci (anche prima di essere attaccato al DOM!). Anche se questo evento per attaccare il "documento" funziona bene, di tutti gli elementi dai nodi fino alla radice sarà "catturare" questi eventi a causa di bubbling degli eventi.Quindi collegare l'evento al più basso antenato comune è una soluzione migliore.

Corso Java - Corsi Java - Corsi programmazione Java

 Corso programmazione Android - Certificazione Android