Asyncio Stack & React.js or Development on the Edge
This is a modal window.
The media could not be loaded, either because the server or network failed or because the format is not supported.
Formal Metadata
| Title |
| |
| Title of Series | ||
| Part Number | 105 | |
| Number of Parts | 173 | |
| Author | ||
| License | CC Attribution - NonCommercial - ShareAlike 3.0 Unported: You are free to use, adapt and copy, distribute and transmit the work or content in adapted or unchanged form for any legal and non-commercial purpose as long as the work is attributed to the author in the manner specified by the author or licensor and the work or content is shared also in adapted form only under the conditions of this | |
| Identifiers | 10.5446/20130 (DOI) | |
| Publisher | ||
| Release Date | ||
| Language | ||
| Production Place | Bilbao, Euskadi, Spain |
Content Metadata
| Subject Area | ||
| Genre | ||
| Abstract |
| |
| Keywords |
EuroPython 2015105 / 173
5
6
7
9
21
27
30
32
36
37
41
43
44
45
47
51
52
54
55
58
63
66
67
68
69
72
74
75
77
79
82
89
92
93
96
97
98
99
101
104
108
111
112
119
121
122
123
131
134
137
138
139
150
160
165
167
173
00:00
Software developerMultiplication signLevel (video gaming)Special unitary groupWebsiteProjective planeDuality (mathematics)Row (database)Point (geometry)Software frameworkView (database)GenderComputer configurationGreatest elementCharge carrierVideo gameWeb servicePhysical systemStack (abstract data type)Web pageWebdesignInternetworkingMobile appTask (computing)Lecture/ConferenceComputer animation
03:00
Positional notationIntegrated development environmentKey (cryptography)MassDecision theoryLevel (video gaming)Library (computing)Physical systemFamilyAreaCodeLecture/ConferenceComputer animation
04:00
Hardware description languageModal logicFormal languageProjective planeLibrary (computing)Instance (computer science)Residual (numerical analysis)GodPhysical systemMathematical analysisImage resolutionEndliche ModelltheorieScripting languageGoodness of fitCodeStandard ModelLecture/ConferenceComputer animation
05:25
Inclusion mapScripting languageBasis <Mathematik>Front and back endsMedical imagingAreaIterationLecture/ConferenceComputer animationJSONXML
06:29
Computer clusterFiber bundleFormal languageFunctional (mathematics)Normal (geometry)Programming languageCodeJSONComputer animation
07:03
Modul <Datentyp>Endliche ModelltheorieMathematicsFunctional (mathematics)Library (computing)Wage labourScripting languageVariable (mathematics)Normal distributionXMLJSON
07:49
Arrow of timeFunctional (mathematics)Variable (mathematics)Error messageBlock (periodic table)Filter <Stochastik>WordTask (computing)Standard deviationLogical constantLokalisationstheorieArrow of timeElectronic mailing listComputer animationLecture/Conference
09:09
Social classString (computer science)Template (C++)Social classNormal (geometry)String (computer science)Formal languageDirection (geometry)Inheritance (object-oriented programming)Polar coordinate systemGoodness of fitVariable (mathematics)Line (geometry)Template (C++)
10:13
Set (mathematics)Level (video gaming)Standard deviationMultiplication signLibrary (computing)Different (Kate Ryan album)Object (grammar)MereologyType theoryRight angleLevel (video gaming)JSONComputer animation
11:20
ProteinStandard deviationUniqueness quantificationSlide ruleSymbol tableMereologyRouter (computing)Electric generatorFormal languageComputer animation
12:13
SummierbarkeitDistanceFormal languageFunctional (mathematics)Category of beingData managementSolomon (pianist)Physical systemExecution unitMedical imagingFiber bundleQuicksortSocial classLecture/ConferenceComputer animation
13:09
CodeFamilyFiber bundleWeb pageCoefficient of determinationStrategy gameDataflowAreaAddress spaceGreatest elementSoftware frameworkConnectivity (graph theory)Interface (computing)Right angleSet (mathematics)Projective planeStandard deviationWeb 2.0VirtualizationWeb browserKeyboard shortcutMathematicsLecture/ConferenceComputer animation
15:28
Euclidean vectorElement (mathematics)Social classConnectivity (graph theory)Online helpWeb pageState of matterLine (geometry)TouchscreenVolumenvisualisierungLibrary (computing)Greatest elementPhase transitionQuery languageSet (mathematics)MathematicsServer (computing)JSONSource code
17:41
Keyboard shortcutConnectivity (graph theory)MathematicsError messageState of matterMetadataCategory of beingBasis <Mathematik>Core dumpInterior (topology)Server (computing)Web pageValidity (statistics)Lecture/Conference
18:54
Decision tree learningStack (abstract data type)Software developerConnectivity (graph theory)Object modelEndliche ModelltheorieOrder (biology)Arithmetic meanPhysical systemSatelliteGraph (mathematics)Right anglePhase transitionProjective planeFront and back endsCore dumpUsabilityComputer animation
21:29
Loop (music)Event horizonTask (computing)Metropolitan area networkAtomic nucleusWeb 2.0Function (mathematics)outputPattern languageLevel (video gaming)Physical systemLibrary (computing)Task (computing)DatabaseJSONXML
22:04
Wireless Markup LanguageServer (computing)Client (computing)Error messageIsing-ModellDemosceneView (database)Form (programming)Dependent and independent variablesWeb browserWeb 2.0JSON
23:04
World Wide Web ConsortiumSoftware frameworkClassical physicsSoftware developerConnected spaceInductive reasoningLine (geometry)FluidPoint (geometry)Spontaneous symmetry breakingLibrary (computing)Web 2.0Elasticity (physics)Computer animation
24:27
ArchitectureDependent and independent variablesTime zoneView (database)GradientObject (grammar)Bus (computing)DataflowProjective planeCartesian coordinate systemInteractive televisionComputer animation
25:11
Parameter (computer programming)Real numberArithmetic meanFlow separationRhombusServer (computing)Cartesian coordinate systemEvent horizonCodeLoop (music)Computer animation
25:43
Sampling (statistics)Web 2.0JSON
26:18
AreaRule of inferenceRow (database)Point (geometry)Decision theoryView (database)Library (computing)GenderParameter (computer programming)Projective planeSocial classPosition operatorSoftware maintenanceAuthorizationWeb 2.0Computer animation
27:23
Mobile appInstance (computer science)Metropolitan area networkInferenceObject (grammar)DemosceneOperator (mathematics)Set (mathematics)View (database)Web 2.0Cartesian coordinate systemMobile appComputer animation
28:30
Computer-assisted translationSequenceMathematical optimizationCartesian coordinate systemWeb applicationMiddlewareReal numberFactory (trading post)Physical systemWeb 2.0CodeJSONXML
29:17
SequenceTemplate (C++)Exception handlingError messageView (database)MeasurementGoodness of fitIncidence algebraSoftware developerWordFunctional (mathematics)QuicksortArithmetic meanInformation securityWeb 2.0CoroutineJSONComputer animation
30:33
Web 2.0Cartesian coordinate systemProjective planeComputer fileAuthenticationData storage deviceEmailException handlingSoftware developerTemplate (C++)Condition numberDatabaseFunctional (mathematics)View (database)ImplementationSocket-SchnittstelleNetwork socketClient (computing)Server (computing)Front and back endsDifferent (Kate Ryan album)Task (computing)Data structureMultiplication signSubsetObservational studyForm (programming)Default (computer science)Symbol tableMaxima and minimaQuicksortInferenceWeb serviceMoment (mathematics)Computer animationDrawing
33:02
Context awarenessFunctional (mathematics)AdditionFamilyProcess (computing)Cartesian coordinate systemType theorySet (mathematics)Table (information)Computer animationJSONXML
33:34
Mobile appAsynchronous Transfer ModeType theoryAsynchronous Transfer ModeSet (mathematics)Proxy serverMechanism designLevel (video gaming)Software developerSocial classRight angleCartesian coordinate systemWeb 2.0XMLJSON
34:30
Front and back endsOnline helpProjective planeWeb 2.0Medical imagingTraffic reportingComputer animation
35:07
Numbering schemeDescriptive statisticsProjective planeSimilarity (geometry)Dependent and independent variablesClient (computing)Web applicationCartesian coordinate systemJSON
35:52
Stack (abstract data type)DatabaseSynchronizationWorld Wide Web ConsortiumThumbnailMetropolitan area networkDynamische GeometrieState of matterSpecial unitary groupRange (statistics)outputTime zoneSynchronizationOpen sourceContent (media)Function (mathematics)User interfaceDebuggerCellular automatonGoodness of fitProjective planeMathematical singularityRight angleSlide ruleResultantDirection (geometry)EvoluteTheory of relativityInterface (computing)Software frameworkGeometryObject (grammar)Orientation (vector space)Data managementMeasurementObservational studyMereologyCASE <Informatik>SoftwareWeb 2.0CodeProper mapCustomer relationship managementRevision controlScaling (geometry)DatabasePower (physics)Computer animation
39:46
Multiplication signLecture/Conference
Transcript: English(auto-generated)
00:01
Hello, everyone. I'm very glad to be here. I'm glad to be in Bilbao. This is my first year of Python, and I want to talk about I think your stack and ReactJS development on the edge. But let me start with a small intro. I'm a Python and ReactJS developer,
00:23
and my primary task on my work is designing and developing began API. So I'm like began API master, but let me show how I will get to that stage. Everything starts in 2002
00:45
when I first met Microsoft front page. That was scary times, but that was then I started learning PHP, like standard stack for that time. It was very, very long time ago. And
01:06
then I started my own web design studio and made some sites for corporate sites, internet shops for Ukrainian companies, and then sometime in 2007, I decided that PHP is bad, and started
01:27
looking around on what else I should use, and two options, Ruby or Python, and I decided to start using Python and Django 95 or 96. So I started using Python, and my life
01:48
getting better, better, better. I started my outsourcing career with Django, then switched to Odessa professional services, so we made services for Google, Facebook, and other
02:02
big companies, and then, in 2011, I met Flask, the next big wow Python project, so I primarily switched from Django to Flask. That was a good time, and I used Flask maybe for
02:21
two, three years in a row, but then, in my work, I need to go back to Django, and right now also working with Django as a framework. So, from my point of view, I'm a Python developer for eight years. I'm using Django from ancient times. I'm using Flask from ancient times,
02:46
but I'm not happy. I'm not happy with all these technologies. It's me when I need to figure out why my Django app working slow, or why developers around my team use
03:02
its dot notation for giving ID for foreign key, so it's like mess, mess, mess, and I'm looking around, so I made a decision. I want to switch to JavaScript, and you should be like what? JavaScript? Come on, it's not an answer. I agree with you, because JavaScript
03:27
was bad. It's like in first big JavaScript library was I think it's prototype, and it's big and scary, and then jQuery being on stage, but it's also first it was small,
03:44
but then, oh, mess, mess, mess, and my motto was, like, let's make someone else, because I'm really don't want to make front-end tasks, because when you start making JavaScript code in, I don't know, three, four years ago, you're like why? Why I need to do this?
04:05
Python is very clear, very simple language if we compare it to JavaScript in those days. The biggest JavaScript problems for me, that was no standard models. You know, this script
04:25
mess in templates, like someone includes a script here, someone there, someone there, there, and you don't know where that library introduced it to your project, and it's very
04:42
hard to maintain, because you need to copy-paste all your code across the projects, across the directories, it's a mess. But then Node.js happens, and it's good. It's good that it happens, because Node.js brings npm, and npm starts installing dependencies, and
05:03
when you have a system for installing dependencies, all code resolution starts being easy, easy, and easy, and people around JavaScript world start to deciding how to share their code
05:21
across the different projects, so common JS happens, and then people decided that we don't need so much script inclusions in the pages, so happens, and then people understand that they need to link their code, and then various linters happens, and then even
05:46
some people decided that, okay, we could use Node.js for making backend applications, but it's serious. Okay. How it's very simple example on how it was earlier, yes,
06:07
like, somewhere in template HTML, you need to include all this code, yes, you need to import underscore, then you should use global underscore, and that was mess. But right
06:25
now, in some iterations, JavaScript makes it to some better, yes, you have one bundle, one bundle have all your functions, everything you need, and you in template, in HTML templates,
06:42
all you need to call your functions. It's like in normal programming languages. So, and all code you see is start looking better, better, better. And right now, I want to talk how it is possible which changed in JavaScript world, and I want to welcome
07:06
ECMAScript 2015. It's previously known as ES6, but right now, it's a change named for ES2015. So let's see what JavaScript has. First of all, it's modellers, yes, it's
07:23
like normal modellers from Python. We can use import, we can use import for libraries, for functions, and, as you see, in libraries, we can use export some functions, so we can use this like function like library. Okay, JavaScript has models. It's a good start,
07:48
but also better start that script no more have for defining variables. So, right now, JavaScript have let and const. Const for constants is obvious, so if you try to change
08:07
your constant, you will get an error, and let works properly in blocks, so you don't have all the problems that you have outside inside the blocks, because you can define
08:25
one let only in one block, so it's fixed for ES2015. Next, you don't need to use function special words to execute some very simple tasks. So, if we have in episodes
08:50
some list of with Star Wars episodes, we can filter them with arrow function, so you don't need to write function, then eat them, and then return them, and arrow
09:02
functions couldn't have the body and could have a body. Next, JavaScript ES2015 have normal classes, so this is built-in feature, so we can use normal classes here. Classes
09:22
can have inheritance. Classes have constructor method. Classes, it's like normal classes from other languages, so it's good direction. JavaScript also very bad in the past that
09:42
JavaScript doesn't have multi-lines strings. Right now, they have. You see it's a multi-line string started from third line. It works, and multi-line strings have simple formatting. It's not that good like in Python, because you need to define the variables to use in
10:09
templates before the template, but it's something. Next, this feature, one of the features I use in JavaScript is destructing something. Python also have first type of
10:27
destruction here. We can distract by the variables, but JavaScript also have an object destruction, and when you start using object destruction in JavaScript, all you
10:45
need object destruction in Python, because it's very powerful, and very good thing. Next, JavaScript introduce new types for the standard library. It's map and set.
11:04
It's very, very fun. It's 2015, and map and set only included in JavaScript, and slow, slow pox everywhere. Right now, we have map and set in JavaScript, and more.
11:22
It's not all features of ES2015. There are more features, and I will pause my slides so you can check all the features of ES2015. They have generators and uni-quotes, and
11:43
proxies, symbols, promises, and more, more, and the most brightest part of all of this is that JavaScript, ECMAScript changed how it uses standards. There are no big ... okay,
12:03
next year, there would be ES2016, then ES2017, and then, and new, new, new features would be shipped to standard language. So, in ES2016, maybe there would be comprehensions,
12:20
class properties, functions, functions like we have in Python 3.5, and then, so JavaScript not staying on the place, and corporations and companies around the world are willing to develop better JavaScript. So, not bad, not bad. And maybe, if you ask how to use
12:46
it, you need only one. You need to use Babel for all good things, so Babel supports your bundle management system. With Babel, there are images one and only lint tool, so
13:02
you have three tools for all your needs. Babel for transpiling ES2015 to old ES5, and to make bundles from all your code, and yes, lint to make sure that all your code is confirmed. Everything is starting easier and easier in JS world, so that more
13:28
and more better projects start developing around JS world, and there is how I found
13:41
ReactJS. When I started learning about ES2015, I checked that many, many people are looking on how to use this old cool features, and they decided to use this old cool features with ReactJS. What is ReactJS? ReactJS is a painless UI framework. It's only UI.
14:04
It's only framework for making user interface, so it's no even handling like in Backbone, so it's no like some data binding like in Angular. It's like only framework for
14:21
rendering your components to web page, and it uses virtual DOM as like standard browser DOM is very, very heavy. ReactJS introduces to the world virtual DOM concepts that are used right now by many other JavaScript frameworks, and that concept is willing you
14:45
to use lightwise components and change it, and do everything faster, faster, and faster. And the main feature of the ReactJS is one-way reactive data flow. It means that you can
15:04
send all you need to the components only one way from the top to the bottom. I see this in the slides. And ReactJS has a very strong community around, so there are a lot of already built-in components, so your start is very easy because there are a lot of tutorials,
15:24
a lot of docs, a lot of everything. So this is the most easier and most simplest ReactJS component. You see it's simple class which you need to define render method. This React
15:42
component will render hello Python to the React container element on the page. Okay, this is an example with the state. When the state changed, you see the state definition
16:02
on the second line, and then using state after the render method. When the state changed, the render method would be re-related. So you change the state, and the component will render. So this is the main idea of React. When the state changed, everything re-renders. And you see, yes, when we click on the button, the state changed, and our
16:32
body will be re-rendered. Next, using components. Sorry for not fitting the screen.
16:41
Using components, React make possible to introduce some components, and using them in like HTML text. You see the line with if preview, and we're using the new not HTML tag but
17:02
new component which named markdown. So, like, fetching data, it's next, next. We use a new fetch API for fetching data, so we don't need jQuery or other libraries for fetching data from the server, so we're using fetch and then promises to fetching
17:25
data, and you see when we have good data, we're setting it to the component comments, and when that data is bad, we're setting it like false
17:40
status. And then, in render method, when component first will be mounted, it will have no status, so then we show loading to the user. Then, due to
18:00
status and data, we show our server error or empty data or valid data to the user. It's very easy to use and very easy to write. And then I will show you what means one-way data-binding. It's like you have on the page comments component and comment. We introduce comments, do some fetching data, and then
18:26
mapping all comments to simple comment components. What it means? It means that comment component doesn't change the state because comment
18:41
component have properties, yes, have props. When data changed in higher component, it would be render inner comment component, so in React terms, the comments is a higher order component, and comment is dump component.
19:03
What it means for us like developers is that we need to develop only higher order components on our project, and all reusable dump components should be shareable between our projects, so it's easy to develop. That's not all React
19:27
features. In O4.14, React even splits base React layer and React DOM to different packages. It means that right now, you can use React not only with
19:44
DOM model, you can use React Native which use it in iPhones, and React Canvas which use it in CanvasTech, so you don't need the document object model to use React. And more, React have magnificent routing system, so you
20:04
can develop single-page applications with ease. React have many, many, many reusable components, and React even have many, many, many technologies to fetch data from the server, like Flux, Relay, or GraphQL, and when you
20:27
start using React, you're like, wow, it's really cool. It's easy. It's easy to develop, easy to maintain, easy to introduce your
20:42
components to other people in your team. And here is the question. And what about backend side? What about Python side? I don't want to use anything in Node.js to make in backend. I don't want to use any isomorphic or
21:01
universal or how it's spelled. JavaScript for making backends. So what about Python? And here comes the most intriguing and most new Python, not
21:24
Python library, but Python stack. I think we all know what it means. I think it's very easy. It's included in Python 3.4, and available in Python
21:43
3.3, and I hope that everyone knows what I think about, but I think it's very low-level stack, so you need to introduce libraries for using databases for making web applications, and then how IOHTP makes sense,
22:08
because IOHTP is HTTP client server for Asyncio. It's very easy. I hope you understand what's going on here. It's IOHTP client, and this is
22:25
IOHTP server. This is a simple hello world in IOHTP web. All you need to make your view function a coroutine, and then return a response. So
22:41
everything is easy, and this IOPG is also very easy. All you need is coroutine, and then create pool. It's like all our previous scene code, but made with yield forms. And I think you're ready, and many, many, many
23:08
tools. So when I start looking around the Python, I will look on the Django, Django framework, flask, flask-restless, and many, many solutions, but also
23:23
solutions doesn't feel like better solutions for me because I want to step up. I want to use something new, and here is where IOHTP and I think your stack is fitting my needs. And you see, many libraries already
23:45
developed for, I think, it's like connecting with MySQL, MongoDB, Elastic storage, and many, many other technologies, and even some web frameworks already available, which built on top of IOHTP web. Induction
24:06
and spanner is like flask on IOHTP web, so if you're interested, you may see here. But I want to introduce IOHTP web to you, and this is a beautiful introduction with all features that have that framework. It's very easy, and
24:31
very easy to understand, and very easy to use. And as it used also one way, not like interact one way, one way data-binding flow, but also one
24:46
way flow with request object passing to the view function, you also can enjoy this in your projects. Okay, this is a very simple hello world. This is how you made your applications. It's very similar to the
25:06
flask. I think it's a very flask way to make applications. And this is how you are serving your IOHTP applications. I recommend to use Gunicon, but if Gunicon not fits your needs, you can use, I think, your event
25:24
loop or other solutions. And Gunicon have magic reload flag, so you don't need some reload solutions which are built into Django dev server or flask server, you have code in Gunicon too. Okay, and this is how IOHTP
25:47
web handling get post data. You see it's handling get data, you have get multi-dict like in Django, like in flask, like everywhere, and then you
26:01
have reading from the post data, so, as you need to read this, so you need to yield from, not to block, to read data from the request. And then, okay,
26:21
next, like you add new roads to your application, it's very, very similar to every other solution we have in Python world. Even we have variable roads, it's something like this. It's not very good architectural decision
26:43
from my point of view, because if we compare this to Django or flask, in Django and flask, we have project ID like positional argument to the view function, but here, we read it from matching for dict. It's not
27:04
very good solution for me, but I think Andrei Svetlov is author and maintainer of this library, and he will have a big class about using IOHTP web on Wednesday, so you can ask him why he decided to do this. And then,
27:25
yes, you can use named roads, you can use everything roads, so you can use everything, yes, you can, as the main, one of the greatest abilities of IOHTP web is that
27:44
application is inherited from the dict, so you can just modify dict like you need. Here, just put settings to the updates, so every app in your, when you get app,
28:02
you have your settings, so you don't need to import your settings any more. So, and next, that app is appended to your request object, so you see you don't need to do from import
28:20
settings, so from something import settings, you just use your application with settings in the view, directly in the view. And then, how to customise your IOHTP web? You should use middlewares. There are a lot of middlewares for user sessions for
28:45
every scene, and this is an example of middleware and how to use it with your web application, and this is a real code for using the book tool bar middleware factory or session middleware,
29:04
so you could have your tool bar or session middleware in your IOHTP web application, so it's very, very easy, and very, very similar to other solutions in Python. And the middleware is like handling exceptions, all you need to catch an exception, and then rendering an error view.
29:30
So user sessions, once more, once again, so it's like using session, first you introduce middleware, then you read in from the session, not working IOH and then write to the session,
29:44
so everything is clear, and everything is easy to use. Even IOHTP web could be used for rendering templates. I'm not sure that we need to use IOHTP for rendering templates, because it's not that solution, but it could be used, so first you need to set up
30:09
Jinja 2 example, and then just render to play it, and this decorator is obviously coroutine, so you don't need to decorate your view function with coroutine again.
30:23
Or if you need to some more, you could use random template function, so everything is easy, and everything like everywhere, and here you can use, you can serve in static files,
30:44
so it is easy file development, so everything is okay on your development server, so everything like everywhere in Python, and next is how you can use your static files in templates.
31:01
Okay, and more, as a brief introduction, so it's not every feature that IOHTP web has, it also has web sockets, except header custom conditions for rows, class-based handlers, so you can use not view functions but class-based
31:24
solutions for handling the routing, and I say it again, IOHTP web has web sockets built in, so you don't need to look around on how to implement web sockets in my web application,
31:41
so just use IOHTP web, and you have your web socket server and client. So real-world usage. I use IOHTP web for back-end API. It is obvious for projects
32:00
from money tracker, and that project is looking for my task around different issue targets like Jira, like Pivotal, like others, and it may be possible to track time which I spent for fixing some issues, and this is a simple structure of my project.
32:29
You see it's nothing new. I have application pi. When I have my application, I have use pi. When I have my global views, I have storage pi layer for working with database and have
32:51
API and also, I don't know, sub-apps for API and also for writing authentication for that project,
33:02
and there are several additional functions I use in my
33:22
functions and tools I use in my projects, like adding roads for the application, simplifying adding roads for the application. It's immutable settings. We use mapping type
33:40
proxy from Python 3.3, so our settings are immutable. We can use debug mode in the application. So, right now, IOHTP web is very raw. It's only on the beginning, so it's many, many features not introduced or not developed, but there are many that we need to
34:09
develop, but I think in several next months, the ecosystem around the IOHTP web would be
34:22
larger, larger, larger, so we could use it like we use Flask or Django without any pain. And then, the most interesting thing that I discovered when I used IOHTP web for my API
34:42
backend is that I should use JSON Scammer for scamming my data, like I could use this same Scammer for validating data on backend and on frontend, and here, with a little help of my project, I'm using a Scammer for adding the project. You see, we have this kind of
35:09
Scammer that the project can have name, slack, and description, and the project would respond with its ID, and then how to use, yes? We should validate request on the server,
35:28
and then we should validate response on the client with one similar Scammer. It's very good, but also very raw solution for validating for you, for ensuring that we have proper data
35:45
in the IOHTP web application and in ReactJS application. And then there's a question. Why might I need your stack? So, there are a lot of already developed solutions in Django,
36:05
in Flask, so why do I need to switch on? Come on, because it's cool and trendy. Just switch on because you just need to check it out, check where Python world is heading.
36:24
Honestly, you need it when your database API is when you have a lot of requests to the external APIs, so you could use all the power of asynchronous input output.
36:46
When you need your code to be executed in async style, and that needs to be executed in predictable style, so you don't need any magic which provides other solutions. In that case,
37:07
you should consider to use your stack on the backend, and the summary. I think the future is here. I suggest that you use Python 3.4 for all good things, because
37:27
if you're still using Python 2 like me on the work, it's so-so. Python 3.4 is stable. It's a very good version of the Python. You should use it in the work for your
37:49
pet projects or something, because your HTTP web is easy to start, easy to use, so you could have proper, I think, your web framework. IOPG have scale alchemy,
38:06
so you should forget about the REM. You don't need object relationship management. You should just use IOPG scale alchemy. If you miss something, just support it. I think your stack,
38:22
it's not that easy, or it's not that hard, so just don't forget to pay back to open-source software. From other parts of my slides, JavaScript also makes a very great step in
38:42
right direction. Many tools around JavaScript is matching, so right now, you could use, you could write your user interface code without the pain. Building, bundling is easy. Webpack. Linting is easy. Making UI is easy. React. So it's how I see the evolution of
39:10
making user interfaces around the Python. We should start using more, I think, your stack on the back-end, and using proper tools like React on the front-end, and this relation
39:29
makes it happen. This relation makes it able to build very simple, very easy web applications,
39:40
and this is a true story. Okay. I'll answer the other questions. Thank you, Igor. We unfortunately are out of time for questions, but if you have something to ask, don't hesitate to reach out to Igor in the hallways and ask him.
40:04
The next session here, we start in five minutes. I have a small bonus. It's how it looks in Python 3.5.