Curiosidades sobre linguagens de programação. Apresentação realizada no Startup Dev Day.

1. 11 HISTÓRIAS E 1 SEGREDO
Luiz Borba
http://borba.blog.br

2. 1989Estudante
1991
Programador
1994
Empreendedor
Analista
de
Tecnologia
1998
Líder
Técnico
2000
2001
Arquiteto de
Software
2005
Scrum
Master
2010
Consultor em
Tecnologia
2014(?)
Consultor em
Negócios
Quem é
Luiz Borba?
http://borba.blog.br

3. O Pirulito

4. “All non-trivial abstractions,
to some degree, are leaky.”
- Joel Spolsky

5. Linguagens de
programação são leaky
abstractions.

7. Temos obrigação de
conhecer o que a
linguagem que
utilizamos faz por
debaixo dos panos.

8. “When someone says: ‘I
want a programming
language in which I need
only say what I wish done’,
give him a lollipop.”
- Alan J. Perlis

9. Mergulhe

10. O bug
existencial

11. “The most likely way for the
world to be destroyed, most
experts agree, is by accident.
That's where we come in; we're
computer professionals. We
cause accidents.”
- Nathaniel Borenstein

12. Qual a melhor
forma de
aprender uma
linguagem?

13. A Internet não
esteve sempre
por aqui...

14. NÃO HÁ NADA
DE ERRADO EM
LER LIVROS

15. Não programe por
coincidência.

16. Aprenda

17. Eis o mistério
da FÉ

18. |”May 2013” can’t be found|
”””May 2013”” can’t be found”
””May 2013” can’t be found”
‘”May 2013” can’t be found’

19. #include <stdio.h>
main()
[
int value = 1;
while(value<=3)
[
printf(|Value is %dn|, value);
value++;
]
return array{1};
]

20. Qual a origem do QWERTY?

21. O KALQ vinga?

23. Não há progresso sem
desafios. Desafie o
“status quo”

24. Desafie

25. Tanto faz dá na
cabeça quanto na
cabeça dá?

26. sort(lista)
ou
lista.sort()

27. Reflita

28. Mister M

29. salvar(objeto) {
broker.beginTrans();
broker.save(objeto);
broker.commit();
}

30. salvar(objeto) {
broker.save(objeto);
}
<transactional-methods>
<method>salvar</method>
</transactional-methods>

31. @Transactional
salvar(objeto) {
broker.save(objeto);
}

32. Aspect-Oriented
Programming
(AOP) é bacana

33. Aspect-Oriented
Programming
(AOP) é pura bosta

34. Esse livro
é bom pra
caralho

35. ...já esse
livro é uma
merda

36. “Eu vou desdizer
Aquilo tudo que eu lhe disse antes
Eu prefiro ser
Essa metamorfose ambulante
Do que ter aquela velha opinião
Formada sobre tudo”

37. Mude

38. Funcional ou
Orientado a Objeto?

39. “Software is getting slower
faster than hardware
becomes faster.”
- Niklaus Wirth

40. •Funções de alta ordem
•Imutabilidade
•Sem efeitos colaterais
•Pattern Matching
•Recursão
•Currying
•Lazy Evaluation
•Continuations
•Closures
•Functional Composition
•Referencial Transparency
•Monads

41. Linguagens Multi-
Paradigmáticas

42. Antene-se

43. Vietnã da
computação

44. Object-Relational Mapping
(ORM)
Linguagens Orientadas a Objetos
Banco de Dados Relacionais

45. NoSQL
mas nada é para sempre

46. Experimente

47. COBOL morreu

48. ou CONSERVADORA
Java é uma linguagem
REVOLUCIONÁRIA

51. ENTERRE

52. A Pior Linguagem
do Mundo

53. ‘5’ + 3 = 53
‘5’ - 2 = 2
‘’ == ‘0’ // false
0 == ‘’ // true
false == undefined // false
false == null // false
null == undefined // true

54. Qual a linguagem?

55. ACEITE

56. Linguagem
Verde

57. Consumo de energia é cada
dia mais importante

58. Teremos linguagens onde
poderemos medir o
consumo do código
produzido?

59. Viaje

60. O que você quer
ser quando
crescer?

61. É possível ser
programador e ganhar
dinheiro?

62. SEJA FIEL
A VOCÊ

63. ...e o segredo?

64. Rust

65. “Rust is a general purpose,
multi-paradigm, compiled
programming language
developed by Mozilla Research”
- Wikipedia

66. Está sendo usada para criar
o Servo, um novo browser
engine experimental

68. C++ não é apropriada para
criar sistemas paralelos e
seguros ao mesmo tempo

69. Rust foi projetada para ter
a mesma performance de
C/C++ mas sem o mesmo
risco de bugs ou falhas de
segurança

70. fn main() {
println(“hello world”);
}

71. use core::rand::RngUtil;
fn main() {
for ["Alice", "Bob", "Carol"].each |&name| {
do spawn {
let v = rand::Rng().shuffle([1, 2, 3]);
for v.each |&num| {
print(fmt!("%s says: '%d'n", name, num))
}
}
}
}

72. Type
Memory safety
Concurrency
Generics
Exception handling
Memory model
Compilation model
system static, nominal, linear, algebraic, locally inferred
no null or dangling pointers, no buffer overflows
lightweight tasks with message passing, no shared memory
type parameterization with type classes
unrecoverable unwinding with task isolation
optional task-local GC, safe pointer types with region analysis
ahead-of-time, C/C++ compatible

73. let hi = "hi";
let mut count = 0;
while count < 10 {
io::println(fmt!("count: %?", count));
count += 1;
}
Imutável por default

74. fn angle(vector: (float, float)) -> float {
let pi = float::consts::pi;
match vector {
(0f, y) if y < 0f => 1.5 * pi,
(0f, y) => 0.5 * pi,
(x, y) => float::atan(y / x)
}
}
Pattern Matching

75. struct Point {
x: float,
y: float
}
let mut mypoint = Point { x: 1.0, y: 1.0 };
let origin = Point { x: 0.0, y: 0.0 };
mypoint.y += 1.0; // mypoint is mutable, and its fields as well
origin.y += 1.0; // ERROR: assigning to immutable field
Structs

76. fn line(a: int, b: int, x: int) -> int
{
a * x + b
}
Funções

77. Owning Pointers (~)
fn f() {
let x: ~int = ~1024; // allocate space and initialize an int
// on the heap
println(fmt!("%d", *x));
} // <-- the memory that x pointed at is automatically freed here
let x = ~5;
let z = x; // no new memory allocated, x can no longer be used

78. fn foo() {
let x: @int = @1024; // allocate space and initialize an int
// on the heap
bar(x); // pass it to `bar`
println(fmt!("%d", *x)); // print it on the screen
} // <-- the memory can be freed here
fn bar(x: @int) {
let y: @int = x; // make a new smart pointer to `x`
} // <-- despite `y` going out of scope,the memory is *not* freed here
Managed Pointers (@)

79. fn dogshow() {
let dogs: [~Dog * 3] = [
~Dog { name: ~"Spot" },
~Dog { name: ~"Fido" },
~Dog { name: ~"Snoopy" },
];
let winner: &Dog = dogs[1];// note use of `&` to form a reference
for dogs.each |dog| {
println(fmt!("Say hello to %s", dog.name));
}
println(fmt!("And the winner is: %s!", winner.name));
} // <-- all dogs destroyed here
Borrowed Pointers (&)

80. Freezing
let mut x = 5;
{
let y = &x; // x is now frozen, it cannot be modified
}
// x is now unfrozen again

81. use core::task::spawn;
// Print something profound in a different task using a named function
fn print_message() { println("I am running in a different task!"); }
spawn(print_message);
// Print something more profound in a different task using a lambda expression
spawn( || println("I am also running in a different task!") );
// The canonical way to spawn is using `do` notation
do spawn {
println("I too am running in a different task!");
}
Tasks

82. OBRIGADO!
Luiz Borba
http://borba.blog.br