-
Notifications
You must be signed in to change notification settings - Fork 3
/
Copy pathschedule-formatted.xml
6895 lines (6895 loc) · 427 KB
/
schedule-formatted.xml
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
505
506
507
508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
544
545
546
547
548
549
550
551
552
553
554
555
556
557
558
559
560
561
562
563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
579
580
581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
596
597
598
599
600
601
602
603
604
605
606
607
608
609
610
611
612
613
614
615
616
617
618
619
620
621
622
623
624
625
626
627
628
629
630
631
632
633
634
635
636
637
638
639
640
641
642
643
644
645
646
647
648
649
650
651
652
653
654
655
656
657
658
659
660
661
662
663
664
665
666
667
668
669
670
671
672
673
674
675
676
677
678
679
680
681
682
683
684
685
686
687
688
689
690
691
692
693
694
695
696
697
698
699
700
701
702
703
704
705
706
707
708
709
710
711
712
713
714
715
716
717
718
719
720
721
722
723
724
725
726
727
728
729
730
731
732
733
734
735
736
737
738
739
740
741
742
743
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
784
785
786
787
788
789
790
791
792
793
794
795
796
797
798
799
800
801
802
803
804
805
806
807
808
809
810
811
812
813
814
815
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
858
859
860
861
862
863
864
865
866
867
868
869
870
871
872
873
874
875
876
877
878
879
880
881
882
883
884
885
886
887
888
889
890
891
892
893
894
895
896
897
898
899
900
901
902
903
904
905
906
907
908
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
928
929
930
931
932
933
934
935
936
937
938
939
940
941
942
943
944
945
946
947
948
949
950
951
952
953
954
955
956
957
958
959
960
961
962
963
964
965
966
967
968
969
970
971
972
973
974
975
976
977
978
979
980
981
982
983
984
985
986
987
988
989
990
991
992
993
994
995
996
997
998
999
1000
<?xml version="1.0"?>
<schedule created="2014-07-13T11:40:02.693714">
<day date="2014-07-21">
<entry id="1">
<category/>
<audience/>
<topics/>
<start>0930</start>
<duration>30</duration>
<room>C01, B05/B06, B07/B08, B09, A08</room>
<title>Breakfast</title>
<description/>
<speakers/>
</entry>
<entry id="37">
<category/>
<audience/>
<topics/>
<start>1030</start>
<duration>30</duration>
<room id="1">C01</room>
<title>Welcome</title>
<description/>
<speakers/>
</entry>
<entry id="118">
<category>Keynote</category>
<audience>Novice</audience>
<topics>
<topic>Other</topic>
</topics>
<start>1100</start>
<duration>45</duration>
<room id="1">C01</room>
<title>One year of Snowden, what's next?</title>
<abstract>Since June 2013, disclosed by Edward Snowden, we learn more and more facts about American and British spies’ deep appetite for information, economic spying and the methods they use to collect data. They systematically tapped international communications on a scale that only few people could imagine. But what are the consequences for societies when they now know about the NSA metadata repository capable of taking in billions of "events" daily to collected and analyze? Is there a way to defend against an agency with a monstrous secret budget?</abstract>
<description>Since June 2013, disclosed by Edward Snowden, we learn more and more facts about American and British spies’ deep appetite for information, economic spying and the methods they use to collect data. They systematically tapped international communications on a scale that only few people could imagine. But what are the consequences for societies when they now know about the NSA metadata repository capable of taking in billions of "events" daily to collected and analyze? Is there a way to defend against an agency with a monstrous secret budget?</description>
<speakers>
<speaker id="1332">
<name>Constanze Kurz</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/1332/</profile>
<description>Constanze Kurz works at the University of Applied Sciences in Berlin as a computer scientist. She is the spokeswoman of the German Chaos Computer Club, Europe’s largest hacker group. She is an expert on surveillance techniques and co-author of technical analyses on voting computers, data retention and anti-terror laws for the German Constitutional Court.</description>
<image>https://ep2014.europython.euhttps://media.ep14.org/site_media/avatars/xWbxpPTjVcg.jpg</image>
</speaker>
</speakers>
</entry>
<entry id="11">
<category/>
<audience/>
<topics/>
<start>1200</start>
<duration>30</duration>
<room id="1">C01</room>
<title>pymove3D Winner Announcement</title>
<description>The pymove3D competition was running until May 1st, 2014 (http://pymove3d.pysv.org). In this session, the winners will be announced.</description>
<speakers/>
</entry>
<entry id="6">
<category/>
<audience/>
<topics/>
<start>1230</start>
<duration>90</duration>
<room>C01, B05/B06, B07/B08, B09, A08</room>
<title>Lunch</title>
<description/>
<speakers/>
</entry>
<entry id="121">
<category>Keynote</category>
<audience>Novice</audience>
<topics>
<topic>Other</topic>
</topics>
<start>1400</start>
<duration>45</duration>
<room id="1">C01</room>
<title>What can python learn from Haskell?</title>
<abstract>What can we learn from Erlang or Haskell for building reliable high
concurrency services? Bob was involved in many Python projects but
argues that for some domains there may be better methods found
elsewhere. He started looking for alternatives back in 2006 when
building high concurrency services at Mochi Media (originally with
Twisted), which led him to the land of Erlang and later Haskell. Bob is
going to talk about what he learned along the way. In particular, he’ll
cover some techniques that are used in functional programming languages
and how they can be used to solve problems in more performant, robust
and/or concise ways than the standard practices in Python. He is also
going to discuss some potential ways that the Python language and its
library ecosystem could evolve accordingly.</abstract>
<description>What can we learn from Erlang or Haskell for building reliable high
concurrency services? Bob was involved in many Python projects but
argues that for some domains there may be better methods found
elsewhere. He started looking for alternatives back in 2006 when
building high concurrency services at Mochi Media (originally with
Twisted), which led him to the land of Erlang and later Haskell. Bob is
going to talk about what he learned along the way. In particular, he’ll
cover some techniques that are used in functional programming languages
and how they can be used to solve problems in more performant, robust
and/or concise ways than the standard practices in Python. He is also
going to discuss some potential ways that the Python language and its
library ecosystem could evolve accordingly.</description>
<speakers>
<speaker id="1331">
<name>Bob Ippolito</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/1331/</profile>
<description>Bob Ippolito is an entrepreneur and polyglot open source developer from San Francisco, CA. His open source contributions include the json library for Python, the MochiKit framework for Javascript, and the mochiweb web server for Erlang. He’s founder and former CTO of Mochi Media, Inc. and currently dedicates his time to advising startups and working with non-profits such as Mission Bit and The College Initiative as a volunteer educator.</description>
<image>https://ep2014.europython.euhttps://media.ep14.org/site_media/avatars/bob_ippolito.jpg</image>
</speaker>
</speakers>
</entry>
<entry id="93">
<category>Training</category>
<audience>Advanced</audience>
<topics>
<topic>System Administration</topic>
</topics>
<start>1400</start>
<duration>180</duration>
<room id="7">A05/A06</room>
<title>Deploying and managing FreeBSD jails with mr.awsome, fabric and ansible</title>
<abstract>FreeBSD jails provide a light-weight but powerful and secure way to virtualise services. The combination of mr.awsome (provisioning), ansible (declarative configuration) and Fabric (imperative configuration and maintenance) allow you to manage them elegantly, combining the best of each approach.</abstract>
<description>FreeBSD jails provide a light-weight but powerful and secure way to virtualise services. However, the *BSD world has sort of stood on the side lines as the recent advances in systems deployment have developed. I.e. while vagrant, puppet, chef, ansible etc. have gained a great deal of acceptance in the Linux world, they often only consider BSD as an afterthought, which is a shame.

Well, mr.awsome has changed this! With its declarative provisioning approach you simply define a jail host and its jails and mr.awsome will go about and make it so.

Configuring a jail then simply becomes a matter of applying one or more ansible playbooks to it and maintenance operations such as performing updates, backups, managing services etc. that don't quite fit the declarative approach of ansible can then easily be applied using Fabric - all powered by a single, canonical configuration!

By separating provisioning from declarative and imperative configuration each area becomes much more concise and clean.

Having great Python tools for each of these areas allows mr.awsome to tie them together on API level to provide a seemless, powerful solution that becomes greater than the sum of its parts.

</description>
<speakers>
<speaker id="387">
<name>Tom Lazar</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/387/</profile>
<description>A self-employed grey-beard Python web developer with a background in systems administration and addicted to writing free, open source software.</description>
<image/>
</speaker>
</speakers>
</entry>
<entry id="46">
<category>Training</category>
<audience>Novice</audience>
<topics>
<topic>Other</topic>
</topics>
<start>1400</start>
<duration>180</duration>
<room id="6">A03/A04</room>
<title>An intro to Blender modeling and scripting </title>
<abstract>This training introduces you to the marvelous world of Blender, the popular opensource 3d computer graphics software. The goal is to create step by step some stunning 3d art by the end of the training giving you the knowledge to start having fun with Blender and python.</abstract>
<description>Blender’s basics *120 minutes*
-----------------
3D modeling tools, materials and textures, lighting and camera management. 

Going deeper *60 minutes*
---------------
Physics simulation! Smoke, fluids, particles, rigid and soft bodies will all be under your control.</description>
<speakers>
<speaker id="110">
<name>Federico Frenguelli</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/110/</profile>
<description>Federico is a Python/C++ developer at evonove. He is a co-organizer of DjangoVillage and a Blender lover.</description>
<image>https://ep2014.europython.euhttps://media.ep14.org/site_media/avatars/gravatar_1.jpeg</image>
</speaker>
</speakers>
</entry>
<entry id="12">
<category/>
<audience/>
<topics/>
<start>1445</start>
<duration>45</duration>
<room id="1">C01</room>
<title>Lightning Talks</title>
<description>A lightning talk is a short talk, typically only five minutes in duration, providing an opportunity for participants - particularly people not featured in the main programme - to deliver a presentation on a subject of their choosing. Speakers need to sign up before the session on the conference website.</description>
<speakers/>
</entry>
<entry id="13">
<category/>
<audience/>
<topics/>
<start>1530</start>
<duration>30</duration>
<room>C01, B05/B06, B07/B08, B09, A08</room>
<title>Coffee Break</title>
<description/>
<speakers/>
</entry>
<entry id="67">
<category/>
<audience/>
<topics/>
<start>1600</start>
<duration>60</duration>
<room id="1">C01</room>
<title>Recruiting Session</title>
<description/>
<speakers/>
</entry>
<entry id="62">
<category/>
<audience/>
<topics/>
<start>1700</start>
<duration>120</duration>
<room>B05/B06, B07/B08, B09</room>
<title>Poster and Recruiting Session</title>
<description/>
<speakers/>
</entry>
<entry id="64">
<category/>
<audience/>
<topics/>
<start>1900</start>
<duration>180</duration>
<room>B09</room>
<title>Sponsored Event: RhodeCode</title>
<description>## RESERVE YOUR PLACE AT THE RHODECODE HIRING EVENT

Reserve your place and join us at the RhodeCode recruitment evening on Monday July 21, from 19:00 - 22:00. The reception will be held at the same conference centre as [EuroPython 2014](https://ep2014.europython.eu/en/), once the opening day sessions come to a close. You will have the chance to sit down with us and get to know us better. We want to discuss our goals, your passion for development, and the opportunities that we currently have to join the team.


We need the best talent to join us as we expand the functionality of our core product, [RhodeCode Enterprise](https://rhodecode.com/features). This will give you the chance to put your stamp on the future direction of how RhodeCode Enterprise will better the lives of millions of developers daily. 

We will be providing a fully catered meal with a wide variety of food, to be sampled with some of that famous German beer. In addition to discussing the future of RhodeCode you will get to meet us in person. As a company we aim to create an ethos of openness and empowerment. Everyone who joins us will be responsible for their own work, have their voice heard, and opinions valued when it comes to deciding our future direction. 

**Reserve your place by sending a tweet [@rhodecode](https://twitter.com/rhodecode) or email [[email protected]](mailto:[email protected]).** 
We look forward to meeting you. </description>
<speakers/>
</entry>
</day>
<day date="2014-07-22">
<entry id="120">
<category>Keynote</category>
<audience>Novice</audience>
<topics>
<topic>Testing</topic>
</topics>
<start>0900</start>
<duration>45</duration>
<room id="1">C01</room>
<title>Will I still be able to get a job in 2024 if I don't do TDD?</title>
<abstract>Geoffrey Moores's book "Crossing the chasm" outlines the difficulties
faced by a new, disruptive technology, when adoption moves from
innovators and visionaries into the mainstream. Test Driven Development
is clearly a disruptive technology, that changes the way you approach
software design and testing. It hasn't yet been embraced by everyone,
but is it just a matter of time? Ten years from now, will a non-TDD
practicing developer experience the horror of being labelled a
technology adoption 'laggard', and be left working exclusively on
dreadfully boring legacy systems?

It could be a smart move to get down to your nearest Coding Dojo and
practice TDD on some Code Katas. On the other hand, the thing with
disruptive technologies is that even they can become disrupted when
something better comes along. What about Property-Based Testing?
Approval Testing? Outside-In Development?

In this talk, I'd like to look at the chasm-crossing potential of TDD
and some related technologies. My aim is that both you and I will still
be able to get a good job in 2024.
</abstract>
<description>Geoffrey Moores's book "Crossing the chasm" outlines the difficulties
faced by a new, disruptive technology, when adoption moves from
innovators and visionaries into the mainstream. Test Driven Development
is clearly a disruptive technology, that changes the way you approach
software design and testing. It hasn't yet been embraced by everyone,
but is it just a matter of time? Ten years from now, will a non-TDD
practicing developer experience the horror of being labelled a
technology adoption 'laggard', and be left working exclusively on
dreadfully boring legacy systems?

It could be a smart move to get down to your nearest Coding Dojo and
practice TDD on some Code Katas. On the other hand, the thing with
disruptive technologies is that even they can become disrupted when
something better comes along. What about Property-Based Testing?
Approval Testing? Outside-In Development?

In this talk, I'd like to look at the chasm-crossing potential of TDD
and some related technologies. My aim is that both you and I will still
be able to get a good job in 2024.
</description>
<speakers>
<speaker id="1330">
<name>Emily Bache</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/1330/</profile>
<description>Emily Bache is a software developer and test automation specialist. Currently an employee of a Swedish company, Pagero, she works on their electronic invoicing product. Together with her team, she regularly delivers working software. Emily has previously worked as a developer in organizations as diverse as small startup and large corporation, using
Python as well as other languages such as Java, Scala and Ruby. For several years she worked as an independent consultant, facilitating many Coding Dojos and developer training events. Emily is a well-known conference speaker, and author of “The Coding Dojo Handbook”. She is originally from the U.K. but now lives in Göteborg, Sweden.</description>
<image>https://ep2014.europython.euhttps://media.ep14.org/site_media/avatars/photo_1.jpg</image>
</speaker>
</speakers>
</entry>
<entry id="22">
<category>Talk</category>
<audience>Novice</audience>
<topics>
<topic>System Administration</topic>
</topics>
<start>1000</start>
<duration>30</duration>
<room id="1">C01</room>
<title>Statistics 101 for System Administrators</title>
<abstract>Python allows every sysadmin to run (and learn) basic statistics on system data, replacing sed, awk, bc and gnuplot with an unique, reusable and interactive framework.

The talk is a case study where python allowed us to highlight some network performance points in minutes using itertools, scipy and matplotlib.

The presentation includes code snippets and a brief plot discussion.
</abstract>
<description>#Statistics 101 for System Administrators

## Agenda
* A latency issue
* Data distribution
* 30 seconds correlation with pearsonr
* Combinating data
* Plotting and the power of color

## An use case 
- Network latency issues
- Correlate latency with other events 

## First statistics 
- we created our parsing library 
- [using various recipes](http://chimera.labs.oreilly.com/books/1230000000393/ch06.html)
- Having the data in a dict like

> table = {
> 'time': [ 1,2,3, ..],
> 'elapsed': [ 0.12, 12.43, ..],
> 'error': [ 2, 0, ..],
> 'size': [123,3223, ..],
> 'peers': [2313, 2303, ..],

- It's easy to get max, min and standard deviation

> print [k, max(v), min(v), stats.mean(v) ] for k,v in table.items() ]

## Distribution 
- A distribution shows event frequency 

> from matplotlib import pyplot
> pyplot.hist(table['elapsed'])

- Time and Size distributions

## (Linear) Correlation 
- What's correlation
- What's not correlation
- pearsonr and probability
- catch for linear correlation

> from scipy.stats.stats import pearsonr
> a, b = range(0,10), range(0,20, 2)
> c = [randint(0,10) for x in a]
> pearsonr(a, b), pearsonr(a,c)
> (1.0, 0.0), (0.43, 0.2)

## Combinations 
- using itertools.combinations
- netfishing correlation

>from itertools import combination
>for f1, f2 in combinations(table, 2):
> r, p_value = pearsonr(table[f1], table[f2])
> print("the correlation between %s and %s is: %s" % (f1, f2, r))
> print("the probability of a given distribution (see manual) is: %s" % p_value)

## Plot always 

- pearsonr finds *only* linear correlation
- our eyes work better :P
- so...plot always!
- color is the 3d dimension of a plot!

> from pyplot import scatter, title, xlabel, ylabel, legend
> from pyplot import savefig, close as closefig
>
> for f1, f2 in combinations(table, 2):
> scatter(table[f1], table[2], label="%s_%s" % (f1,f2))
> # add legend and other labels
> r, p = pearsonr(table[f1], table[f2])
> title("Correlation: %s v %s, %s" % (f1, f2, r))
> xlabel(f1), ylabel(f2)
> legend(loc='upper left') # show the legend in a suitable corner
> savefig(f1 + "_" + f2 + ".png")
> closefig()


## Wrap Up! 
- do not use pearsonr to *exclude* relation between events
- plots may serve better
- scatter plot can show a system thruput and exclude correlation between fields A and fields B
- continue collecting results


</description>
<speakers>
<speaker id="248">
<name>Roberto Polli</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/248/</profile>
<description>Roberto works at Babel, migrating big mail infrastructures to open solutions. Develops in Python, C and Java to foster communities around various FLOSS, trying to bring both social and IT innovation.

He's a Red Hat Certified Engineer and Virtualization Administrator, but loves maintaining free software, including the caldav java library: caldav4j.

A life ago he took a Math degree, and he's really proud of it.
</description>
<image>https://ep2014.europython.euhttps://media.ep14.org/site_media/avatars/rpolli_400.jpg</image>
</speaker>
</speakers>
</entry>
<entry id="123">
<category>Talk</category>
<audience>Advanced</audience>
<topics>
<topic>Python Core</topic>
</topics>
<start>1000</start>
<duration>30</duration>
<room id="4">B09</room>
<title>The Magic of Attribute Access</title>
<abstract>Have you ever wondered how the "self" argument appears when you call a method? Did you know there is a general mechanism behind it? Come learn all about attributes and descriptors.</abstract>
<description>The first part of this talk will describe what exactly happens when you
read or write an attribute in Python.

While this behavior is, of course, explained in the Python docs,
more precisely in the [Data model][1] section and [related][2] [writeups][3],
the documentation gives one a "bag of tools" and leaves combining them
to the reader.

This talk, on the other hand, will present one chunk of functionality,
the attribute lookup, and show how its mechanisms and customization
options work together to provide the flexibility (and gotchas) Python provides.
The topics covered will be:

* method resolution order, with a nod to the C3 algorithm
* instance-, class-, and metaclass-level variables
* `__dict__` and `__slots__`
* data/non-data descriptors
* special methods (`__getattr__`, `__getattribute__`, `__setattr__`, `__dir__`)


In the second part of the talk, I will show how to use the customization
primitives explained before on several interesting and/or useful examples:

* A proxy object using `__getattr__`
* Generic desciptor - an ORM column sketch
* the rudimentary `@property`, method, `staticmethod` reimplemented in
pure Python (explained [here][2] and elsewhere), which lead to
* SQLAlchemy's [`@hybrid_proprerty`][4]
* Pyramid's deceptively simple memoizing decorator, [`@reify`][5]
* An ["Unpacked" tuple properties][6] example to drive home the idea that
descriptors can do more than provide attribute access
(and mention weak dicts as a way to non-intrusively store data on an object)


(These are subject to change as I compose the talk. Also some examples may
end up interleaved with the theory.)

Hopefully I'll have time to conclude with a remark about how Python manages to be
a "simple language" despite having these relatively complex mechanisms.


[1]: http://docs.python.org/3/reference/datamodel.html
[2]: http://docs.python.org/3/howto/descriptor.html
[3]: https://www.python.org/download/releases/2.3/mro/
[4]: http://docs.sqlalchemy.org/en/rel_0_9/orm/extensions/hybrid.html
[5]: http://docs.pylonsproject.org/projects/pyramid/en/latest/api/decorator.html
[6]: https://gist.github.com/encukou/9789993</description>
<speakers>
<speaker id="606">
<name>Petr Viktorin</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/606/</profile>
<description>Petr is a Python geek, Pyvo meetup organizer and mentor of PyLadies Brno. He works on the FreeIPA project at Red Hat.</description>
<image>https://ep2014.europython.euhttps://media.ep14.org/site_media/avatars/IMG_8115.jpg</image>
</speaker>
</speakers>
</entry>
<entry id="55">
<category>Talk</category>
<audience>Advanced</audience>
<topics>
<topic>Other</topic>
</topics>
<start>1000</start>
<duration>30</duration>
<room id="2">B05/B06</room>
<title>Amanda: A New Generation of Distributed Services Framework</title>
<abstract>Abstract
=======

To help create award winning visual effects, MPC developed a distributed service-oriented platform, Amanda.
Amanda allows developers of any level to write a service that is presented to users across 8 facilities globally without them requiring any
knowledge of building large concurrent systems. It allows artists and developers across different domains to work with
clearly defined API's and gives the service developer control over what and how data can and should be accessed.

The talk will cover how to set up such a platform from the ground up. Starting at the service level building it out with
additional modules and technologies until the fully distributed system, covering topics such as concurrency, componetisation and monitoring that allow the
fine tuning of setups depending on the type of work being undertaken and changing business needs.</abstract>
<description>Presentation outline
====================

We'll start off with a quick overview of a movie production pipeline which will set the stage
for how Amanda provides artists with the tools they need to develop and streamline the production process
as well as Amanda's crucial function as a robust framework for the support and development teams.
Going over some stats, up to 250.000 service calls a minute during World War Z for example (for frame of reference this is
twice the average rate of stackoverflow.com), I'll highlight some of the problems encountered with the 1st generation.
Initially developed in 2007 and replaced last year it had several flaws in regards to scalability, maintainability and future proofing.
From there I'll introduce the 2nd generation which is build on the principle of componentisation and building blocks. Every part of the system
needs to be replaceable and this needs to be possible from the configuration.

During the presentation we will be stepping through the different building blocks, how they have been set up, how they slot together
and how we monitor, trace and test the system from the ground up. Starting at the lowest level with services we'll slowly
step through the different blocks necessary to build a fault tolerant, distributed and scalable platform.
We made sure that the platform is not tied into any specific technology but allows the use of the best technologies
depending on the type of work being undertaken and changing business needs and technological advances.

Service development and testing
-------------------------------

Our development teams build applications for artists creating visual effects through to management teams coordinating productions.
A service-based architecture was chosen to provide consistent interfaces across the many different environments where this is required.
We provide an ecosystem where developers of any level can safely write a service (a set of instructions regarding a
specific topic) that are presented to developers and technical artists globally.
To write a service the developer doesn't need any knowledge in regards to building large concurrent systems.
The service is implemented through a simple Python API and the provided ecosystem allows services to exist in a standalone manner.
The service concept was separated from the platform hosting it. This allows hosting in any application that provides a
standard container (a service provider). Extracting this allowed for more rigorous and simple testing of services;
it also allows developers to provide fake versions of their services publicly against which client code can be tested.
The adage ʻeverything as a serviceʼ was applied to the development of internal facilities.
This includes our management tools and the developer console, which presents the documentation of services and methods
available to developers through a web interface.
Infrastructure services were introduced to present an interface to facilities provided to a regular service, for example
databases, configuration and centralized logging.
Services can call other services and, similarly to infrastructures, services can be replaced with different services depending on the configuration.
Services are exposed to a service (or client as we will see later) via a service provider just like in applications.
Setting services up with the above patterns allows developers to iterate quickly and to include services within testing frameworks.
It has also provided a standardized form across projects allowing developers to support and add to unfamiliar code easily.
And last but not least it has given us full abstractions at all levels, users of services do not need to know the code underneath the hood
be it at a service level or at an infrastructure level.


Building the cluster
--------------------

Rather than building a single system, the new architecture defines a set of building blocks for constructing a
distributed service platform. These can provide adapters for best of breed third party tools or, where necessary,
custom implementations of functionality. Configuration is used to determine the number and types of modules to use
and the parameters with which to initialize them. This allows the same platform to be used for small instances at
a developerʼs desk up to a production environment of many nodes. The design enables improved components to be
swapped into the existing system whilst forming the basis for an entirely new design.

Most practical applications require the service provider to handle multiple requests at the same time.
Amanda provides a set of interchangeable concurrency modules. This allows the most appropriate Python model
for parallel processing to be chosen. For work involving heavy I/O work we choose approaches that avoid waiting
for the GIL, for example multiple processes and greenlets/coroutines, whilst for CPU bound work we can use threads
which may prove more performant. Having the option to choose between mechanisms is important since there is not a
solution that neatly fits all use cases. A pluggable concurrency abstraction also allows integration of new libraries
as they become available. In future this might include the new asyncio (formerly Tulip) core library for Python 3.3+.

To benefit from concurrency, resource pooling, caching etc. we don't always want to execute the service locally to the service provider.
Service proxies implement this behavior; they take the service, method and arguments of a request as their input
and return the result. The proxy should be transparent to the service and service provider components. By chaining
proxies, complex routing schemes can be built or analysis performed on the results returned. Some similarity can be
drawn with middle-ware in the Web Services Gateway Interface (WSGI) specification.
Communication between proxy and service provider is served by the transport. This abstraction provides an
asynchronous interface to underlying technologies – Current implementations include queue based AMQP, ontop of
RabbitMQ, and ØMQ and more naïve communications with standard UDP and TCP sockets. Most transports define both client
and server parts of the system – however some, particularly HTTP-based transports, are designed to accept requests directly from external clients.
Requests from external applications commonly use XMLRPC, JSONRPC or straight JSON. Transport implementations can be
interchanged without impacting other components of Amanda or service developers.

In production, a request gateway implemented as a WSGI application fronts the HTTP protocols. Using the standard
web components NGINX and μWSGI we can build a very scalable front end which internally uses the service provider, proxy, transport
pattern to offload the requests to a backend. The gateway can also provide standard web facilities such as template rendering
(through the Jinja2 library1) for general web clients. The gateway was a requirement as requests originate from applications
written in many languages including C++, Python, JavaScript and domain specific languages such as mel. For us it was
important that the client used across all those languages was a proven standard and lightweight. Most requests are served
in near realtime (6ms round trip times) and are presented to the client in a synchronous way so using a frontend that supports a large number
of HTTP like protocols allowed us to keep the clients simple and present the platform to an extremely wide variety of
languages. Additionally, through the frontend, we can render a web page and present that directly if the requests was made
from a browser.

The final behavior of the platform is defined in configuration. This allows the platform to be tuned to suit
the work that a particular service is performing (I/O vs CPU bound). It is important to remember that every single
component mentioned above be it the concurrency, transport, proxies or frontend can be changed, removed, updated without
it impacting the service, the developer or any of the other components that make up the platform.

Also important to mention that internally and externally everything is a queue and presented as a queue. Going from the client
to the frontend there is a queue, from the frontend onto the backend there is a queue etc. all the way down to a request
being read of the transport and stored inside a queue until a concurrency object is ready to handle the request with the
service provider.

This is where we think our platform might take a different approach. Rather than building the platform on top of a single
great technology we didn't want to limit ourselves and be able to use all the other great technologies out there.
There is no perfect solution for all problems but allowing to fine tune the platform according to different problems.
The setup can now evolve in line with technological advancements and changes to the industry.


Maintenance and Monitoring (5 mins)
-----------------------------------

We will walk through how we are using the same setup with services, service providers, proxies and transports to manage
clusters around the globe. Once again for our maintenance and monitoring we made sure everything is done as a service so
that if there is a better tool in the future we could adopt it.

Through leveraging the configuration management and remote execute platform Salt, a new cluster can now be provisioned quickly.
Management is itself provided as a service. Through this system, the current state is available and configuration changed across
all servers globally. This has reduced routine maintenance tasks from a half day to a five-minute task, with less
chance of human error. Monitoring and introspection are provided, as a service, to aid in day-to-day support, tuning and to help
support analysis for future development.

Developers of services can trace requests from when they enter the system, producing a report of the sequence of
methods being called, with the supplied arguments. For each call the time spent to fulfill each request is presented.
Care was taken to minimize the impact of this on return result of the request. Due to everything being a queue we
can collect the metrics after the result has been put back onto the transport and send to the user and thus minimize the impact
of this collection on returning the result of the request
This means that there is no requirement to put the system into a debug mode in order to obtain execution metrics.

With logging being a service we can dynamically change the logging configuration on a per service basis by making a
request to the logging service taking away the need of changing configuration and restarting the service which
often means a problem might have disappeared due to the reset.

Future/Conclusion (1 min)
-------------------------

Whilst developing the new generation of the platform there have been a number of possible applications that have
emerged. The way in which we are able to scale the system would be suitable to run in a cloud environment –
especially with the improvements to management allowing new nodes to be provisioned quickly. The ease of writing
and integrating new components would allow integration with infrastructure provided by third-party cloud vendors.
Other areas of interest include a smaller version of the platform running locally on a userʼs workstation and
services for management of generic processes.

Main technologies and libraries currently used:
------------------------------------------

* Threading
* Gevent
* Eventlet
* Multiprocessing
* ZeroMQ
* RabbitMQ
* uwsgi
* Flask
* Salt
* nginx
</description>
<speakers>
<speaker id="373">
<name>Jozef van Eenbergen</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/373/</profile>
<description>Jozef has been working with Python since 2009 and programming with different languages since 2005. He is currently part of the Infrastructure team at MPC where he has been responsible for Amanda, MPC's distributed service framework which is used as the backbone of their international Visual Effects pipeline.

Jozef enjoys trying out new tools and technologies and tries to stay on top of new developments as much possible.

In his spare time he likes to travel, watch a good movie, play the drums or work on CG/art projects as that is what got him into the Visual Effects industry.

He is currently based in London and lived in The Netherlands, France and Canada before that.</description>
<image>https://ep2014.europython.euhttps://media.ep14.org/site_media/avatars/oscar.jpg</image>
</speaker>
</speakers>
</entry>
<entry id="94">
<category>Talk</category>
<audience>Advanced</audience>
<topics>
<topic>Gaming</topic>
</topics>
<start>1000</start>
<duration>30</duration>
<room id="5">A08</room>
<title>Mobile Games to the Cloud With Python</title>
<abstract>When a mobile game development company decides to switch to a more cloud based development it is faced with obstacles different from those its used to on mobile devices. This talk explains how Python provided us with most of the infrastructure for this task and how a Python game backend was built as a result.</abstract>
<description>#### The Talk

This talk has two goals. Showing the audience the lessons we learned during a project which moved a simple mobile game to a server backend is our first intention. In addition to that we want to describe how such a system works in a real life example, to show which problems and which requirements arise in its creation. When the audience leaves the talk they will know how a real-life mobile game uses Python for powering the backend servers.


#### The Problem

Most of the game development for mobile devices is focused on running the game on the device. The game designers and game developers play a primary role in creating the product. The server backend plays a supporting role providing a multiplayer or social experience to the users. Indeed, at Nanobit Ltd., things were also done that way. We had a small Python infrastructure built around Django which provided a small portion of multiplayer experience for the players. The majority of development was still focused on playing the game on the device. That way of thinking was put to test when we decided to center our future games around the multiplayer experience. Due to the fact that our infrastructure at the time was not enough for what we had in mind, we had to start from scratch. The decision was made to use Python as the center of our new infrastructure.

In order to achieve it, a server backend was needed that would allow the game to be played “in the cloud” with the device only being a terminal to the player. Most of the game logic would have to be processed in the cloud which meant that each player required a constant connection to the backend and with over 100.000 players in our previous games that presented a challenge. How to build an infrastructure which can support that? Since every user action had to be sent to the backend how to process thousands of them quick enough? Those problems were big and were just the start.


#### The Solution

The design of the backend lasted for a couple of months and produced a scalable infrastructure based on “workers” developed in Python, “web servers” that use Tornado and a custom message queue which connected the two. The storage part is a combination of Riak and Redis. Since the backend is scalable new workers and new web servers had to be deployed easily so an orchestration module was build using Fabric. The scalability and launching of new workers and web servers was achieved using Docker for creation and deployment of containers. Each container presents one module of the system (worker, web server, queue). The end result can now support all of our future games and only requires the game logic of each game to be added to the workers.


#### The Technologies

* Python for coding the game logic, web servers. More than 90% of the system was written in Python.
* Fabric
* SQLAlchemy
* Riak
* Redis
* ZeroMQ
* nginx
* Docker
* Websockets
* AWS


#### The Lessons Learned

* How to tune the backend to handle the increasing number of active players.
* How to tackle the problem of frequent connection dropping and reachability issues of poor mobile device Internet connection in Tornado with a little help of Redis.
* How to prevent users from trying to outsmart the system by denying illegal moves.
* How to enable game profile syncing and live updating.
* Improving the performance of workers by prioritizing data being stored to databases (Riak, SQL).
* New issues and lessons show up all the time so there will definitely be more of them by the time of the conference.


#### Basic Outline

1. Intro (5 min)
1. Who are we?
2. How was Python used in our previous games
3. Why we decided to change it all
2. Requirements (6 min)
1. What was the goal of creating the game backend
2. Why was Python our first choice
3. Python backend (14 min)
1. The architecture of the backend
2. Which technologies did we use and how were they connected together
3. How the backend handles the game logic
4. Lessons learned
4. Questions & Answers (5 min)</description>
<speakers>
<speaker id="1103">
<name>Mislav Stipetić</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/1103/</profile>
<description>Backend developer at Nanobit Ltd who likes to play with new technologies. Long time Python user who used it for everything, from servers to state machines.

His favourite new technologies include Redis, Riak and the go programming language. He often wonders how people got anything done before Redis.</description>
<image>https://ep2014.europython.euhttps://media.ep14.org/site_media/avatars/europy_slika_2.jpg</image>
</speaker>
<speaker id="246">
<name>Darko Ronić</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/246/</profile>
<description>Darko works as a Team Leader and Senior Server Developer at Nanobit Ltd, a mobile game development company, where he's using Python on a daily basis along with various technologies such as Amazon AWS, Redis, Riak, GoLang, Tornado, various (No)SQL databases etc. He is still doing some game development when needed but is primary focused on the server side of things.

He's been using Python ever since the company decided they needed a server backend and hasn't looked back.</description>
<image>https://ep2014.europython.euhttps://media.ep14.org/site_media/avatars/10482482_10203146545957141_5357494014741933252_o_1.jpg</image>
</speaker>
</speakers>
</entry>
<entry id="49">
<category>Talk</category>
<audience>Novice</audience>
<topics>
<topic>Best Practices</topic>
</topics>
<start>1000</start>
<duration>30</duration>
<room id="3">B07/B08</room>
<title>Cutting-edge APIs using hypermedia at BSkyB</title>
<abstract>In this talk I will explain what hypermedia enabled API means, I will give an example of such an API and I will take you through the implementation details and the usage of flask, dougrain and HAL in this context.

Also, I will present a brief comparison with an API that is not hypermedia enabled and take you through the advantages of using the hypermedia approach.</abstract>
<description>In the technology community at the moment there is a lot of talk about hypermedia enabled APIs and Web as an Architecture model.

More and more applications nowadays try to adopt the loosely coupled and distributed web like architecture by using hypermedia as an engine of the application state.

In Sky we are successfully implementing this approach for some of our components, and we’ve learnt that the major benefit for us is the scalability that it offers: as an increasingly expanding business with a constantly growing product portfolio, scalability of all our systems is crucial.

In this talk I will share some of the things we learnt, I will explain what hypermedia enabled API means, I will give an example of such an API and I will take you through the implementation details and the usage of flask, dougrain and HAL in this context.

Also, I will present a brief comparison with an API that is not hypermedia enabled and take you through the advantages of using the hypermedia approach.</description>
<speakers>
<speaker id="224">
<name>Adriana Vasiu</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/224/</profile>
<description>Adriana currently works as a Senior Software Developer at BskyB in London, where she has worked for over 2 years. She is agnostic in terms of languages, although her favourite one at the moment is Python.

She works in an agile team which develops features across an entire sales platform and she has learnt a lot from the very skilled and talented people that she has worked with at BSkyB.

Having in total more than 6 years experience, she always concentrates on continuous improvement of the software that she builds, always adapting to the market, learning new things and improving her knowledge.

Adriana sees Europython as an opportunity to share her enthusiasm and motivation towards building software applications in Python, and to expand her knowledge in the language.</description>
<image>https://ep2014.europython.euhttps://media.ep14.org/site_media/avatars/photo-1.JPG</image>
</speaker>
</speakers>
</entry>
<entry id="76">
<category>Training</category>
<audience>Advanced</audience>
<topics>
<topic>Other</topic>
</topics>
<start>1000</start>
<duration>180</duration>
<room id="7">A05/A06</room>
<title>Making your first contribution to OpenStack</title>
<abstract>We will be going through the process of how to make a contribution to OpenStack starting from a DevStack install. Contributions can be either code or documentation. By the end of the session, participants should have all the necessary accounts and tools set up for contributing, know how to submit a contribution to an OpenStack project, understand the OpenStack contribution process and have a first contribution completed or underway, as well as know what are the next steps.
Participants should already be familiar with git, comfortable with Python as well as have a SSH key pair and virtual machine set up with Devstack prepared ahead of the session. You can find instructions on how to do this in the longer description of the session.</abstract>
<description>Taking people from a DevStack install to a first contribution.

Objectives
----------
By the end of the session, participants will:

* have all the necessary accounts and tools set up for contributing
* know how to submit a contribution to an OpenStack component
* understand the OpenStack contribution process
* have a first contribution completed or underway, and know what are the next steps

The process for making both code and documentation contributions is the same in OpenStack. For this session, participants will be encouraged to choose a task of either type.

Pre-requisites:
---------------
Participants should have:

* A basic knowledge of git (cloning a repository, committing)
* A SSH key pair (instructions on how to create one can be found online, for instance [https://unfuddle.com/support/docs/topics/ssh_keypair](https://unfuddle.com/support/docs/topics/ssh_keypair))
* A Virtual Machine (VM) with DevStack installed (see below for details)
* Be comfortable with Python

Some familiarity with cloud concepts may be helpful.

Contributing to OpenStack currently requires signing a Contributor Licence Agreement (CLA). If your employment contract has a restrictive IP clause, you may want to check first with your company lawyers whether you can sign it. See [https://review.openstack.org/static/cla.html](https://review.openstack.org/static/cla.html) for the text of the licence.

Participants are expected to install DevStack in a Virtual Machine (doing it in a VM is important as DevStack cannot be uninstalled) prior to the training to save time and to avoid overloading the Internet connection on the day.

There are many virtualisation software packages that let you create VMs, for example *virt-manager* (Linux), *Vagrant* (Linux, Windows, Mac Os X) or *Virtual Box* (Linux, Windows, Mac OS X). You should install Fedora 20 or Ubuntu 12.04 in the virtual machine.
The installation instructions for DevStack are available at [http://devstack.org](http://devstack.org) : within the VM, clone the repository then run `./stack.sh`. After answering the initial questions, the script can take up to 1 hour to run depending on your connection speed.

If you have a problem installing DevStack we can try and solve it during the day - doing one run-through of `stack.sh` will at least ensure all the packages and software have been downloaded (save/suspend the VM!).

Expected Structure:
--------------------
**30 minutes - Introduction**

Introduction to OpenStack and to the session goals

Environment check, start devstack

**30 minutes - Setting up (one-time only)**

Creating accounts:

- Launchpad (used for bug tracking, single sign-on)
- The Foundation
- Gerrit + CLA (it uses the launchpad account, how gerrit is used)
- Key pair

Devstack tips

**30 minutes - Getting started**

How to choose a bug, bug trackers, low hanging fruits

Reminder of the different OpenStack projects mentioned in the introduction, as well as the documentation and integration tests. Review team vs committer team, +2 process.

Each participant should pick a project and download the code for that project

Ways to find an easy bug:

- low-hanging-fruit
- general bug tracker browsing
- adding a unit test
- developer docs also live in the project's repository (typos, clarifications, etc)

**10 minutes - Break**

**45 minutes - Find & work on a bug**

Participants work on a small task.

There'll be a few tasks ready for people who struggle to find something (missing tests, mostly) but it's unlikely there will be one ready in advance for everyone. Participants will be strongly encouraged to find a task of their own based on their interests and the advice shared prior to the break.

**35 minutes - Submitting the patch**

Gerrit for review

The git-review tool

* setting up git-review
* submitting the patch
* how it can be used for reviewing

The next steps (for your patch, and the community)

Abstract:
---------</description>
<speakers>
<speaker id="377">
<name>Julie Pichon</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/377/</profile>
<description>Julie is a software engineer at Red Hat and works on Horizon, the web dashboard for OpenStack. A big open-source supporter, she likes to get involved in projects aiming to help newcomers get started contributing to open-source. </description>
<image>https://ep2014.europython.euhttps://media.ep14.org/site_media/avatars/julie_pichon.JPG</image>
</speaker>
</speakers>
</entry>
<entry id="73">
<category>Training</category>
<audience>Novice</audience>
<topics>
<topic>Science</topic>
</topics>
<start>1000</start>
<duration>180</duration>
<room id="6">A03/A04</room>
<title>Effective data visualisation in 2D with matplotlib</title>
<abstract>The tutorial will introduce the basic theory of data visualisation and put it to use through [matplotlib](http://matplotlib.org), the popular Python library for creating 2D static and interactive visualisations. To unleash the full power of matplotlib, we will reach under the hood and discover some hidden gems in terms of customisation and working with visual primitives. The participants will be invited to practice their visualisations skills trough a series of examples. They will learn how to build complex data visualisations from ground up and spice them with a bit of interactivity. </abstract>
<description>In our private and professional lives we generate and process large volumes of data, from which we need to extract meaningful patterns and present them data graphically either on paper or web. The goal of the workshop is to arm you with practice-oriented tips that will help you to avoid visual clutter and increase the data density of your graphs.</description>
<speakers>
<speaker id="710">
<name>Bartosz Telenczuk</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/710/</profile>
<description>Bartosz Telenczuk has a PhD in biophysics. He has been active Python user since 2005. He is creator of [svgutils](https://github.com/btel/svg_utils) and he has contributed to many open source Python libraries including numpy and matplotlib. He is also a Python advocate and an instructor at advanced Python schools for scientists]. Currently he is a researcher in France, developing methods to interpret the electrical activity of the brain.</description>
<image/>
</speaker>
</speakers>
</entry>
<entry id="2">
<category/>
<audience/>
<topics/>
<start>1030</start>
<duration>30</duration>
<room>C01, B05/B06, B07/B08, B09, A08</room>
<title>Breakfast</title>
<description/>
<speakers/>
</entry>
<entry id="37">
<category>Talk</category>
<audience>Advanced</audience>
<topics>
<topic>System Administration</topic>
</topics>
<start>1100</start>
<duration>45</duration>
<room id="3">B07/B08</room>
<title>Rethinking packaging, development and deployment</title>
<abstract>In Python, we're trying to solve packaging problems in our own domain, but maybe someone else already solved most our problems.

In the talk I'll show how I develop and deploy Python projects that can be easily mixed with non-Python dependencies.

http://nixos.org/nix/ will be demonstrated to replace technologies in our stack: pip, virtualenv, buildout, ansible, jenkins.</abstract>
<description>Python is often mixed with other languages in development stack, nowadays it's hard to escape any JavaScript dependencies. If you add some C dependencies such as GStreamer to the stack, packaging becomes a burden.

While tweaking our packaging infrastructure will make things better, it's hard to fix fundamental problem of packaging with current ad-hoc solutions in Python domain.

Using Nix (http://nixos.org/nix/) for about a year gave me an insight that solving packaging problem at operating system level (bottom-up) is a better approach.

For example, wouldn't it be cool to have "virtualenv" implemented inside your package manager, so you could isolate also non-Python dependencies and not just Python packages for your project and not worry if system was updated?

We'll also show what benefits do we get by using the same tool for development and deployment and how little we have to do to deploy our application.

To see how Haskell community is touching the same subject, see blog post http://ocharles.org.uk/blog/posts/2014-02-04-how-i-develop-with-nixos.html

</description>
<speakers>
<speaker id="182">
<name>Domen Kožar</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/182/</profile>
<description>Domen is an electrical engineering student dropout focusing on solving problems with Python / Nix / JavaScript / Linux stack using kanban workflow.

He was a GSOC student 4 times (Gentoo, Plone, PylonsProject, PylonsProject).

He's a beer lover and kite-surfer from Ljubljana, Slovenia and proud member of Kiberpipa hackerspace.

His vision is to be paid to work on improving OSS infrastructure.</description>
<image>https://ep2014.europython.euhttps://media.ep14.org/site_media/avatars/domen.jpeg</image>
</speaker>
</speakers>
</entry>
<entry id="69">
<category>Talk</category>
<audience>Advanced</audience>
<topics>
<topic>Python Core</topic>
</topics>
<start>1100</start>
<duration>45</duration>
<room id="2">B05/B06</room>
<title>Extending Python, what is the best option for me?</title>
<abstract>Python is a great language, but there are occasions where we need access to low level operations or connect with some database driver written in C. With the FFI(Foreign function interface) we can connect Python with other languages like C, C++ and even the new Rust. There are some alternatives to achieve this goal, Native Extensions, Ctypes and CFFI. I'll compare this three ways of extending Python.</abstract>
<description>In this talk we will explore all the alternatives in cpython ecosystem to load external libraries. In first place we'll study the principles and how shared libraries work. After that we will look into the internals of CPython to understand how extensions work and how modules are loaded. Then we will study the main three alternatives to extend CPython: Native Extensions, Ctypes and CFFI and how to automate the process. 
Furthermore we will take a look to other python implementations and how we can extend it.</description>
<speakers>
<speaker id="175">
<name>Francisco Fernández Castaño</name>
<profile>https://ep2014.europython.eu/en/accounts/profile/175/</profile>
<description>Francisco Fernandez works as a software engineer at biicode in Madrid. He uses Python as his main programming language but he also program in other languages like Scala, Go, Clojure... His main interests are distributed systems, functional programming and graph databases. </description>
<image>https://ep2014.europython.euhttps://media.ep14.org/site_media/avatars/foto.jpeg</image>
</speaker>
</speakers>
</entry>
<entry id="109">
<category>Talk</category>
<audience>Advanced</audience>
<topics>